1.c/c++中的const

1 const概述

const 修饰的对象为一个常量,不能被改变

2 c/c++中const的区别

c语言中的const1 const修饰的局部变量,存在栈区,虽然不能通过const修饰的变量去修改栈区内容,但是可以通过地址去修改

const修饰的全局变量是保存在常量区,不能通过变量名去修改.也不能通过地址去修改。

const修饰的全局变量,如果其他文件想使用,直接extern声明外部可用即可。

c中的：

在main.c中

#include <stdio.h>
const int b = 10;//const修饰的全局变量保存在常量区
 void test03()
 {
 extern const int num;//声明num是外部可用的
 printf("num=%d\n",num);
 }
 //const修饰的全局变量
 void test02()
 {
 //b = 100;
 int *p = &b;
 *p = 100;//错误的 不能修改常量区的内容
 printf("b=%d\n",b);
 }
 //const修饰的局部变量
 void test01()
 {
 //在c语言中const修饰的变量保存在栈区
 const int a = 10;
 //a = 100;
 int *p = &a;
 *p = 100;
 printf("a=%d\n",a);
 }
 int main()
 {
 test03();
 return 0;
 }

onst int num = 1;

c++中的const：

1 const修饰的局部变量赋值常量时,局部变量保存在符号表中,修改不了,是一个常量

2 const修饰的全局变量保存在常量区,不能被修改

3 const修饰的全局变量默认是内部链接属性,加上extern修饰变成外部链接属性

mian.cpp

#include <iostream>
 using namespace std;
 const int b = 1;
 void test03()
 {
 extern const int num;
 cout << num << endl;
 }
 void test02()
 {
 //const修饰的全局变量存在常量区
 int *p = (int *)&b;
 *p = 100;//错误的
 cout << b<< endl;
 }
 //c++中const修饰的局部变量
 void test01()
 {
 //c++中const修饰的局部变量存在符号表中
 const int a = 10;
 //a = 100;
 //对const修饰的局部变量取地址 编译器会产生一个临时变量来保存a的地址
 // int tmp = a; int *p = &tmp
 int *p = (int *)&a;
 cout << a << endl;
}
int main()
 {
 test03();
 return 0;
 }

extern const int num = 1;// const修饰的全局变量默认是内部链接属性.

c/c++中的const异同

相同的点:

c和c++中的const修饰的全局变量都是保存在常量区,不能被修改

不同的点:

c语言中const修饰的局部变量赋值为常量时,,局部变量保存在栈区,可以被指针修

改

c++中,const修饰的局部变量赋值为常量时,局部变量保存符号表中,不能被修改

c语言中const修饰的全局变量默认是外部链接属性

c++语言中const修饰的全局变量默认是内部链接属性

c++中const修饰的变量,分配内存情况

const修饰的全局变量在常量区分配了内存

对const修饰的局部变量赋值为常量时,对其取地址,会在栈区分配临时的内存空间

const修饰的局部变量赋值为变量时,局部变量保存在栈区

const修饰的局部变量时一个自定义变量,也是在栈区分配内存

只有一种情况,const'修饰的局部变量被赋值为常量时,这个局部变量保存在符号表中,

符号表后中的变量，编译器直接访问，不会为其开辟空间。

#include <iostream>
 using namespace std;
 const int a = 1;//const修饰的全局变量在常量区分配了内存
 void test01()
{
 const int a = 10;//const修饰的局部变量赋值为常量没有分配内存,存在符号化表中
 int *p = (int *)&a;//对const修饰的局部变量赋值为常量的变量取地址 会分配一个临
时的空间 int tmp =a *p =&tmp
 }
void test02()
 {
 int b = 2;
 //const修饰的局部变量赋值变量时 局部变量存在栈区
 const int a = b;
 int *p = (int *)&a;
 *p = 100;
 cout << a << endl;
 }
 struct stu
 {
 int a;
 int b;
 };
 void test03()
 {
 //const修饰的变量为自定义变量时,保存在栈区
 const struct stu obj = {1,2};
 struct stu *p = (struct stu *)&obj;
 p‐>a = 3;
 p‐>b = 4;
cout << obj.a << " " << obj.b << endl;
 }
 int main()
 {
test03();
return 0;
 }

尽量以const替换define

有两点原因:

1. const修饰的全局变量或const修饰的局部变量赋值为常量,是有类型的,而define的

宏没有类型

2. const修饰的全局变量或const修饰的局部变量赋值为常量有作用域的,而define的

宏没有作用域

#include <iostream>
 using namespace std;
 namespace A
 {
 const int max = 1024;
 const short max1 = 1024;
 #define MAX 1024
 }
 // 宏没有作用域 宏没有类型(int)
 void fun(int a)
 {
 }
 void fun(short a)
 {
 }
 void test01()
 {
 cout << A::max << endl;
 cout << MAX << endl;
 fun(MAX);//void fun(int a)
 fun(A::max);//void fun(int a)
 fun(A::max1);//void fun(short a)
 }
 int main()
30 {
31
32 return 0;
33 }

宏定义的变量是做替换的，并且是全局的没有作用限制，但是const修饰的变量为常量是有范围的，范围即为原来变量的范围。

2.引用

引用的作用为给变量取别名。

引用的基本用法 ：

原类型 &别名 = 旧名这里的&不是取地址符，而是引用。

在这里取别名后，两者的地址是一样的，且对a操作，b也会跟着操作。

注意事项：

引用一旦初始化,不能更改引用的指向

引用定义时必须初始化

不能引用NULL

引用可以引用任意类型包括数组

&在等号的左边是引用,在等号的右边是取地址

#include <iostream>
 using namespace std;
 void test01()
 {
 int a = 10;
 //引用一旦初始化之后不能改变引用的标识
 int &b = a;
 b = 100;
 cout << a << endl;
int c = 1;
 //b = c; 代表把c的值赋值给b 不是给c取别名为b
 //int &d; 引用定义时必须初始化
 }
 void test02()
 {
 int a[5] = { 1,2,3,4,5 };
 //int(&arr)[5] = a;
 typedef int ARR[5];
 //type & 别名 = 旧名
 ARR & arr = a;
 for (int i = 0; i < 5; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
 }
 int main()
 {
 test02();
return 0;
 }

变量的引用并不会为他开辟空间，只想相当于多了个名字。

函数的引用：

注意：

引用可以作为函数的形参

函数调用时就是 &实参=形参实参的改变影响形参，我们不用指针也可以做到这一点。

不能返回局部变量的引用

//指针方式交换
 void swap(int *x, int *y)
 {
 int tmp = *x;
 *x = *y;
 *y = tmp;
 }
 void test01()
 {
 int a = 10;
 int b = 20;
 swap(&a,&b);
 cout << a << " " << b << endl;
 }
//引用交换
 void swap_ref(int &x, int &y)// int &x =a, int &y =b)
 {
 int tmp = x;
 x = y;
 y = tmp;
 }
int main()
 {
 int a = 10;
 int b = 20;
 swap_ref(a, b);
 swap(&a,&b);
 }

引用的本质

引用的本质是一个指针常量

type &b = a; 编译器底层这么实现的:

type *const b = &a;

#include <iostream>
 using namespace std;
void test01()
 {
 int a = 10;
 int &b = a;//编译器优化 int* const b = &a
 //指针常量 不能改变指针变量的指向
 // b =0x100;
 b = 1000;// *b =1000
 }
 void fun(int *&q)//int *&q = p ==> 编译器 int * const q =&p
 {
 }
 void test02()
 {
 int *p = NULL;
 fun(p);
 }

指针的引用

套用引用公式: type &q = p

假设:

type为指针类型

void fun ( int * & q ) // int* &q = p

{

}

void test ()

{

int * p = NULL ;

fun ( p );

}

5 常量引用

const type &p = q;

常量引用代表不能通过引用去修改引用标识的那块空间

#include <iostream>
 using namespace std;
 void test01()
 {
 int a = 10;
 // const修饰的是引用& 不能通过引用去修改引用的这块空间的内容
 const int &b = a;
 //b = 1000;//err
 }
 void test02()
 {
 //int &b = 100;//不能引用常量
 const int &b = 1;//int tmp =1 ,const int &b= tmp
 }
 int main()
 {
 return 0;
 }

内联函数

内联函数的基本概念

在 c++ 中，预定义宏的概念是用内联函数来实现的，而内联函数本身也是一个真正的函数。

内联函数具有普通函数的所有行为。唯一不同之处在于内联函数会在适当的地方像预定义宏

一样展开，所以不需要函数调用的开销。因此应该不使用宏，使用内联函数。在普通函数 ( 非成员函数 ) 函数前面加上 inline 关键字使之成为内联函数。

但是必须注意必须

函数体和声明结合在一起，否则编译器将它作为普通函数来对待。

inline void func(int a);

以上写法没有任何效果，仅仅是声明函数，应该如下方式来做 :

inline int func(int a){return ++;}

注意 : 编译器将会检查函数参数列表使用是否正确，并返回值 ( 进行必要的转换 ) 。这些事预

处理器无法完成的。

但是函数调用就会占用空间：，但是内联函数相对于普通函数的优势只是省去了函数调用时候的压

栈，跳转，返回的开销。我们可以理解为内联函数是以空间换时间。

内联函数就是继承了宏函数的高效,并且不会出错,还可以当成类的成员函数用

2 宏函数和内联函数的区别

宏函数的替换是发生在预处理阶段

内联函数的替换是发生在编译阶段

宏函数容易出错,内联函数不会

内联函数和宏函数一样,都省去了调用函数的开销。

举个例子

//宏函数
#define MYCOMPARE(a,b) (a)<(b)?(a):(b)
//内联函数
 inline int mycpmpare(int a, int b)
 {
 return a < b ? a : b;
 }
 void test02()
 {
 int a = 1;
 int b = 5;
 //int c = MYCOMPARE(++a, b);// ++a<b?++a:b
 int c = mycpmpare(++a, b);
 cout << c << endl;
 }

类的成员函数默认编译器会将它做成内联函数

class Person{
public:
 Person(){ cout << "构造函数!" << endl; }
 void PrintPerson(){ cout << "输出Person!" << endl; }
 }

类里的成员函数默认为内联函数。

内联仅仅只是给编译器一个建议，编译器不一定会接受这种建议，如果你没有将函数声明为

内联函数，那么编译器也可能将此函数做内联编译。一个好的编译器将会内联小的、简单的

函数

c++学习之c++对c的扩展2