C++中多才多艺的 const

清风剑盼

1. 定义一个常全局变量

1. const int global = 100; // 初始化之后不可再赋值

复制代码

这样的

1. global

复制代码

实际上是一个常量，这是C++用来取代宏定义的其中一种措施，

1. const

复制代码

常量有类型检测，提高编译器的效率。

2. 定义常指针

这有两个版本，分别是：

1. const int *p1 = &a; // p1不能修改它所指向的目标
   
2. int const *p1 = &a; // p1的另一种等价形式
   
3. int *const p2 = &a; // p2本身不可修改

复制代码

上述代码中的p1经常被用作函数参数，用以限制指针的权限，在安全性方面功不可没。p2用的很少，我们很少需要一个本身指向不可变的指针

3. 定义一个STL的常迭代器

这也有类似的两个版本：

1. vector::const_iterator it1; // it1不能修改它所指代的目标对象
   
2. 
   
3. const vector::iterator it2; // it2本身不可修改

复制代码

由于迭代器实际上就是广义指针，因此it1实际上相当于上述代码的p1，it2相当于上述代码的p2，同理it1用的较多，用来限制迭代器的权限。

4. 定义一个类的内部常成员

包括常成员数据和常成员方法：

1. class text
   
2. 
   
3. {
   
4. 
   
5.      const int aconst = 100; // 常成员数据，必须初始化
   
6. 
   
7.      void func(void) const; // 常成员方法，只能由常对象调用
   
8. 
   
9.      static int astatic;
   
10. 
    
11. };

复制代码

类的常成员数据

1. aconst

复制代码

，意味着类对象无法对其修改，这个很容易理解。至于类的常成员方法

1. func

复制代码

就破费脑力了，语法上的理解是，

1. func

复制代码

不能修改任何一个类对象的bit，这是显而易见的，这也正是C++标准对

1. const

复制代码

成员方法的定义。\
来近距离看看func方法的使用：

1. int text::astatic = 100; // 类外初始化静态数据
   
2. 
   
3. void text::func(void) const // 类外定义const成员方法
   
4. 
   
5. {
   
6. 
   
7. astatic = 200; // 没毛病，astatic不是对象数据，此处可以被修改
   
8. 
   
9. aconst = 200; // 错误！const型函数不可修改类对象数据
   
10. 
    
11. }

复制代码

定义如上的成员方法很重要，因为它明确地告诉了类的使用者，哪些函数可以修改类对象信息，哪些不会修改类对象信息。
像

1. func()

复制代码

这样的函数

1. const

复制代码

成员方法，只能被常对象调用，以确保不违反权限紧缩原则，比如：

1. text t1; // 普通对象t1
   
2. const text t2; // const型对象t2
   
3. t1.func(); // 错误！普通对象不可调用常成员方法
   
4. t2.func();

复制代码

注意：函数本体的

1. const

复制代码

属性是可以被视为重载的依据的，换句话说如果以上类text提供了

1. non-const

复制代码

版本的

1. func

复制代码

函数，那么t1将会自动调用

1. non-const

复制代码

那个版本。
以上陈述似乎平淡乏味，但考虑C++语法规定的这种

1. bit-wise

复制代码

特性的常成员在处理类成员指针，并且指针指向类外部内存时，情况也许会变得有趣。

5. bit-wise和logical-wise常特性

所谓

1. bit-wise constness

复制代码

指的是类对象的内部内存意义上只读约束，而

1. loigcal-wise

复制代码

指的是逻辑意义上的只读约束。编译器没有智能，它只能实现

1. bit-wise

复制代码

意义上的约束，下面的例子讨论

1. const

复制代码

成员

1. operator[ ]

复制代码

的表现可以帮助理解：

1. class text
   
2. {
   
3.      ... ...
   
4.      char &operator[ ](int pos) const;
   
5. private:
   
6.      char *p;
   
7. };
   
8. 
   
9. // const关键字保证了该成员方法只能被 const 对象调用
   
10. char &text::operator[ ](int pos) const
    
11. {
    
12.       return p[pos];
    
13. }

复制代码

上述代码中，类text存储真正字符串的地方是指针 p 指向的内存区域，假设此时定义一个

1. const

复制代码

型的常对象，那么它只能保证类内部信息（也就是p本身）不被修改，却无法保证其所指向的内存区域的安全性。来看下面的代码：

1. const text ct("abcd");
   
2. 
   
3. ct[0] = 'A'; // 一个被编译器允许却跟逻辑相悖的语句

复制代码

此处ct是一个

1. const

复制代码

型对象，从字面理解出发，我们应该认为ct对象是一个常量，我们应该无法通过任何方式修改其内部信息，但可惜，ct里面的字符串信息实际上并不存在在类内存区域中，于是就出现了可以对一个const型对象进行赋值的有趣现象。
解决以上问题也不难，可以改写 operator[ ] 成员方法的返回值类型：

1. const char &operator[ ](int pos) const;

复制代码

此时就再也不能对 ct[0] 赋值了，但这只是个个例，关键我们要掌握的内容是：如果我们的类对象拥有成员指针，那么一般意义上的

1. const

复制代码

成员方法只能保证

1. bits-wise

复制代码

的常量性（即保证类对象内部的内存信息不被修改），但无法保证所谓的

1. logical-wise

复制代码

的常量性（即保证逻辑上哪些信息不被修改）。
到此这篇关于C++中的 const的文章就介绍到这了,更多相关C++中的const内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

单细胞火腿召

感谢楼主，顶。

颜杰

感谢楼主分享。