c++ const用法小结

时间:2024-10-01 18:35:20

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