C++ const总结与小技巧

具体的说明转自 http://my.oschina.net/wxwHome/blog/37144

1.const变量声明

const int n1;                   //  错误,声明的同时必须要伴随着初始化.

const int n1 = 3;               //  正确.

 

extern const int n2;            //  正确.

const int* pn1;                 //  正确.

 

int* const pn2;                 //  错误,声明的同时必须要伴随着初始化.

int n2 = 5;

int* const pn2 = &n2;           //  正确.

 

const int nArray1[];            //  错误,声明的同时必须要伴随着初始化.

const int nArray2[] = { 1 } ;   //  正确.

 

int n3 = 5;

int nArray3[n3];                //  错误.

 

const int n4 = 5;

int nArray4[n4];                //  正确.

 

const int n5 = 5;

const int nArray5[n5];          //  错误,声明的同时必须要伴随着初始化.

 

const int n6 = 1;

const int nArray6[n6] = { 1 };  //  正确.

 

const int nArray7[] = { 1,2 };

int nArray8[nArray7[1]];        //  错误.

 

2. const int* pn(int const* pn)与int* const pn的区别.

(1)const int* pn;这样声明是可行的;int* const pn;错误的,声明必须伴随着初始化.

(2) const int* pn(int const* pn)

//  pn为常量指针;const修饰的是*pn,*pn表示指针指向的值,用const修饰*pn,*pn是常量,是不能改变的.

int a = 5;

int b = 8;

const int* pn = &a; //  正确.

pn = &b;                //  正确.

 *pn = 3                //  错误.

//-------------------------------------------------------

int* const pn      

//  pn为指针常量;const修饰的是pn,pn是不能改变的,但是pn指向的内容是可以改变的.

int a = 5;

int b = 8;

int* const pn = &a; //  正确.

pn = &b;                //  错误.

*pn = 3             //  正确.

(3)对于const int* const pn

int a = 5;

int b = 8;

const int* const pn = &a;   //  正确.

pn = &b;                    //  错误.

*pn = 6;                    //  错误.

 

3.const int& n

//  引用必须初始化,而且初始化后这个引用不能在引用其它的变量.

int a = 5;

int b = 8;

const int& n = a;   //  正确.

n = b;              //  错误.

 

4.类型检查

//  可以把一个non const指针赋给一个const指针,不可以把const指针赋给non const指针.

//  但是可以使用某些手段进行转换.

const int a     = 5;

const int* pn   = &a;                   //  正确.

int* pn2        = &a;                   //  错误.

int* pn3        = (int*)&a;             //  正确.

int* pn4        = const_cast<int*>(&a); //  正确.

pn              = pn3;                  //  正确.

pn              = pn4;                  //  正确.

到这里解决一个C++常见问题，想动态的构造出一个const int，让它以后天长地久地不变。

那么我的解决方式就是const int& A = a + 0; 如果只是用一个a的话，这时即便再更改a，A的值也不会变，A的指向又不变（注意，恰恰利用了它不指向a。）所以它是一个真的是const.

当然了，编译器可不当它是const，操作诸如bitset<A>编译器还是会报错的。。。