c++ const用法小结

const用法

1，定义全局变量的内存分配问题

#define  Pi_1  3.14       //使用#define宏

const double Pi_2 = 3.14    //使用const,这时候Pi并没有放入内存中

double  a = Pi_2;  //这时候才为Pi分配内存,不过后面再有这样的定义也不会再分配内存

double  b = Pi_1;  //编译时分配内存

double  c = Pi_2;  //不会再分配内存,

double  d = Pi_1;  //编译时再分配内存

const定义的变量，系统只为它分配一次内存,而使用#define定义的常量宏，能分配好多次,这样const就很节约空间

2，const修饰变量

1、限定符声明变量只能被读

　　 const int i=5；

　　 int j=0；

　　 ……

　　 i=j；　 //非法，导致编译错误

　　 j=i；　 //合法

2、 必须初始化

　　 const int i=5；　　　 //合法

　　 const int j；　　　　 //非法，导致编译错误

3、在另一连接文件中引用const常量

　　 extern const int i；　　　 //合法

　　 extern const int j=10；　  //非法，常量不可以被再次赋值

3，指向常量的指针变量

int a = 10;

int b = 20;

const int* p = &a;    // assignment of read-only location ‘* p’, 即*p为只读的，不能对*p进行写操作。

int const* p1 = &a;   //同上

*p = 11;            // error

p = &b;            // ok, 此时 *p = 20;

4，常量指针

int * const p2 = &a;  //assignment of read-only variable ‘p2’, 即p2始终指向&a，不可被改变，但是可对*p2 做读写操作。

p2 = &b;           // error

*p2 = b;            // ok , 此时 *p2 = 20，由于p2始终指向&a，所以此时 a = 20；

5，指向常量的常量指针

const int * const p3 = &a; //此时p3始终指向 &a，并且不能对*p3做“写”操作。但是可以通过 a = 12 去改变*p3的值。

6，const限定类的成员函数

这种用法只在C++中有用(C语言中没有成员函数).如:

class classname

{

public:

int func() const

{... ...;}

}

采用这种const后置的形式一种规定，为了不引起混淆，在此函数的声明中和定义中均要使用const，因为const已经成为类型信息的一部分.但要注意，这种情况下，该函数不能修改类的非静态（static）数据成员，也不能在函数中调用其它非const的函数.比如:

class base

{

int x;

static int y;

public:

void foo() { cout << “foo” << endl;}

void foo() const { cout << “foo const” << endl;}

void foo1() { cout << “foo1” << endl;}

void foo2() const { cout << “foo2 const” << endl;}

static void foo3() { cout << “foo3” << endl;}

void test() const

{

int c;

x = 5;   //错误

y = 10;  //正确

foo()    //正确

foo1();  //错误

foo2();  //正确

foo3()   //正确

c = 10;  //正确

}

}

这种情况下，在函数内部无法改变成员数据x的值，因此编译器会报错:"l-value secifies const object".

尽管函数名和参数列表都相同，void foo( ) const成员函数是可以与void foo( )并存的，可以形成重载! 我们假设调用语句为obj.foo()，如果obj为non-const对象，则调用foo()。如果obj为const对象，则调用foo()const。另外要注意，假如没有提供foo()const，则const obj调用foo()将会报错。但假如是没有提供foo()，则non-const obj调用foo()const是完全没有问题的。也就是说，non-const对象可以调用const函数(当然也可以调用non-const函数)，但const对象不能调用non-const函数。

const关键字所起作用的本质，就是把隐藏着的默认的this指针参数，改成const类型。也就是说：假如void foo( )函数被编译器改写为 void foo(T* pThis)，则void foo( ) const将会被改写为void foo(const T* pThis) 。i.e. 在函数末尾添加一个const，就相当于在隐藏的this参数类型前加一个const.

这样做有两个效果，第一：编译器将不允许foo()const修改pThis指向的对象的成员。第二、const对象只能调用const成员函数，否则就会报错说把const T* 转化为T* 会丢失qualifier