const关键字的基本思想就是将一个变量变成常量,试图从语言设计者的角度去分析引入该关键字的动机。
我猜测原因如下:
1)提醒程序员,某些值是常量,如PI。或该值在程序运行期间是不变的,防止程序员误修改。对于多模块开发,头文件引用复杂的系统来说,这是很重要的,如果不能在编译期阻止常量被误修改,那么这些修改将引起运行时调试困难的问题。
2)改进c语言中的#define预处理宏,1)中提到的问题使用#define宏也能够得到解决,但是#define宏作为解决方案存在一些缺陷:a)#define宏会产生二义性。 b)#define宏不支持类型,无法进行类型检测,这对于强类型语言来说,无疑是难以接受的。3)#define宏无法实现后来者const的一些功能。如函数参数传址时,防止被调用函数在调用者不知情的情况下随意修改参数。再如c++类机制中的const成员的访问性控制。
通常的理解,const修饰的变量是不可修改的。其实不然,const关键字在某种程度上来说只是一个面向编译器和程序员的幌子,并不能保证被修饰的内容的不变性。
下面分别按照const的部分用法来分析一下:
1) const修饰局部变量,即声明一个局部常量
- int main()
- {
- const int con_var1 = 3;
- int * b = (int *)&con_var1;
- *b = 5;
- std::cout <<con_var1 << " "<<*b ;
- return 0;
- }
来看一下汇编代码:
- Dump of assembler code for function main:
- 0x080485ce <+0>: push %ebp
- 0x080485cf <+1>: mov %esp,%ebp
- 0x080485d1 <+3>: and $0xfffffff0,%esp
- 0x080485d4 <+6>: push %ebx
- 0x080485d5 <+7>: sub $0x2c,%esp
- <span style="color:#FF0000;">0x080485d8 <+10>: movl $0x3,0x18(%esp)</span>
- 0x080485e0 <+18>: lea 0x18(%esp),%eax
- 0x080485e4 <+22>: mov %eax,0x1c(%esp)
- 0x080485e8 <+26>: mov 0x1c(%esp),%eax
- 0x080485ec <+30>: movl $0x5,(%eax)
- 0x080485f2 <+36>: mov 0x1c(%esp),%eax
- 0x080485f6 <+40>: mov (%eax),%ebx
- <span style="color:#FF0000;">0x080485f8 <+42>: movl $0x3,0x4(%esp)</span>
- 0x08048600 <+50>: movl $0x804a040,(%esp)
- 0x08048607 <+57>: call 0x8048498 <_ZNSolsEi@plt>
- 0x0804860c <+62>: movl $0x8048760,0x4(%esp)
- 0x08048614 <+70>: mov %eax,(%esp)
- 0x08048617 <+73>: call 0x80484f8 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
- 0x0804861c <+78>: mov %ebx,0x4(%esp)
- 0x08048620 <+82>: mov %eax,(%esp)
- 0x08048623 <+85>: call 0x8048498 <_ZNSolsEi@plt>
- 0x08048628 <+90>: mov $0x0,%eax
- 0x0804862d <+95>: add $0x2c,%esp
- 0x08048630 <+98>: pop %ebx
- 0x08048631 <+99>: mov %ebp,%esp
- 0x08048633 <+101>: pop %ebp
- 0x08048634 <+102>: ret
- End of assembler dump.
- <span style="color:#FF0000;">0x080485d8 <+10>: movl $0x3,0x18(%esp)</span>
这句是con_var1的定义,在栈上分配了内存,并赋值为3。
- 0x080485e0 <+18>: lea 0x18(%esp),%eax
- 0x080485e4 <+22>: mov %eax,0x1c(%esp)
- 0x080485e8 <+26>: mov 0x1c(%esp),%eax
- 0x080485ec <+30>: movl $0x5,(%eax)
上面这段是取con_var1的内存地址,并将该地址中的值改为5.即con_var1在内存中实际的值已经被改写成5了。
既然内存中的值已经被改成5了,那么为什么最后打印出的值没有改变?
- 0x080485f8 <+42>: movl $0x3,0x4(%esp)
- 0x08048600 <+50>: movl $0x804a040,(%esp)
- 0x08048607 <+57>: call 0x8048498 <_ZNSolsEi@plt>
我们发现,上面同样的行为,使用c将得到不同的结果
- int main()
- {
- const int con_var1 = 3;
- int * b = (int *)&con_var1;
- *b = 5;
- printf("%d",con_var1);
- }
于是,我猜测以下结论:
a)对于const修饰的局部常量而言,g++编译器(不同编译器机制未必相同)会为其分配内存,由于是静态分配而且是局部常量,所以分配在栈中。
b)对代码中直接引用到该常量(即该常量直接作为右值使用)的情况,编译器会将其直接替换成定义时赋的值。这样一来,无论运行期该常量所在内存被如何修改,都不会影响常量的使用。对于取址操作&con_var而言,&con_var整体被当作一个右值,没有被编译器替换成常值,这也是为什么既然编译器还要为const修饰的常量分配内存的原因。(const folding技术在这里被用到)。
c)const只在编译期间保证常量被使用时的不变性,无法保证运行期间的行为。程序员直接修改常量会得到一个编译错误,但是使用间接指针修改内存,只要符合语法则不会得到任何错误和警告。因为编译器无法得知你是有意还是无意的修改,但是既然定义成const,那么程序员就不应当修改它,不然直接使用变量定义好了。
d)c语言中原本没有const关键字,后来为了兼容,引入了const,但是编译器对其的操作与c++中不同。
2) const修饰 常量指针或指针常量
- int main()
- {
- int v = 3;
- const int * ptr_cvalue = &v;
- cout <<v;
- cout << *ptr_cvalue;
- v = 5;
- cout <<v ;
- cout<< *ptr_cvalue;
- }
运行结果为5 5,这个结果与const实现这个功能并不冲突,应为const只保证修饰的指针不能被用来修改其指向的内存的值。但是其他手段来修改该内存的值就与const无关了。
这个实验的目的是为了再次说明,const机制并没有在运行期有任何行为,只是编译期的行为。
相类似的,指针本身为常量的也可以通过另一个指向指针的指针来修改其所指向的地址来实现更改。
3)const修饰类成员变量
- #include <iostream>
- using namespace std;
- class A
- {
- public:
- A(int i=1,int j=2):a(i),b(j)
- {};
- //const int c;
- void fun()
- {
- cout<<"a="<<a<<endl;
- cout<<"b="<<b<<endl;
- int *a1 = (int*)&(a);
- *a1 = 5;
- int *b1 = (int*)&(b);
- *b1 = 6;
- cout<<&a<<"="<<a<<endl<<a1<<"="<<*a1<<endl;
- cout<<&b<<"="<<b<<endl<<b1<<"="<<*b1<<endl;
- }
- private:
- const int a;
- const int b;
- };
- int main(int argc, char* argv[])
- {
- A a;
- a.fun();
- cout << &a << endl;
- return 0;
- }
a=1
b=2
0xbff3b9c8=5
0xbff3b9c8=5
0xbff3b9cc=6
0xbff3b9cc=6
0xbff3b9c8
可以看到,类const成员被修改了。
4)函数const传址也是可以被修改的。
5) const意外的收获---全局常量
- #include<iostream>
- using namespace std;
- const int constant=1;
- int main()
- {
- unsigned int addr;
- int * pconst;
- addr=(unsigned int)&constant;
- pconst=(int *)addr;
- cout<<&constant<<" "<<&addr<<endl;
- *pconst=10;//segment fault
- cout<<constant<<endl;
- return 0;
- }
报段错误,这里报错的原因在于:const int constant,这个全局常量内存分配在.rodata段,对于内存分页机制来说,.rodata对应的页是只读的,当试图去修改该段内存时,会引发段错误,这是在运行期的错误。可以说,这是真正能够保证不会被修改的常量。是在操作系统层面实现的。
总结:const关键字是用于约束程序员和编译器的行为的,而不是程序员用以保证程序正确性的良药,除了全局常量外,没有任何机制保证了const声明的常量的不可修改性,要想使得程序中定义的常量不被修改,就只能循规蹈矩的使用它。
(1) 编译器处理方式不同
define宏是在预处理阶段展开。
const常量是编译运行阶段使用。
(2) 类型和安全检查不同
define宏没有类型,不做任何类型检查,仅仅是展开。
const常量有具体的类型,在编译阶段会执行类型检查。
(3) 存储方式不同
define宏仅仅是展开,有多少地方使用,就展开多少次,不会分配内存。
const常量会在内存中分配(可以是堆中也可以是栈中)。
(4)const
(5) 提高了效率。 编译器通常不为普通const常量分配存储空间,而是将它们保存在符号表中,这使得它成为一个编译期间的常量,没有了存储与读内存的操作,使得它的效率也很高。
const 与 #define的比较
(1)
(2)
l
5.3 常量定义规则
l
l
例如:
const
const
5.4 类中的常量
有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的,不能达到目的,于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的,但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的,因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。
const数据成员的初始化只能在类构造函数的初始化表中进行,例如