c/c++中const详解

桃扇骨 2022-09-18 00:59 211阅读 0赞

**一. cons 的作用**

**(1) 可以定义 const 常量**

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **const** **int** Max=100;  
2.    
3.  **int** Array\[Max\];

**(2) 可以保护被修饰的东西，防止意外的修改，增强程序的健壮性**

如果在函数体内修改了i，编译器就会报错；

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **void** f (**const** **int** i)   
2.  \{   
3.      i=10;//error!   
4.  \}

**(3) 为函数重载提供了一个参考**

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  ......  
4.  **void** f(**int** i)       \{......\} //一个函数  
5.  **void** f(**int** i) **const** \{......\} //上一个函数的重载  
6.  ......  
7.  \};

**(4) 可以节省空间，避免不必要的内存分配**

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  \#define PI 3.14159         //常量宏  
2.  **const** doulbe  Pi=3.14159;  //此时并未将Pi放入ROM中  
3.  ......  
4.  **double** i=Pi;               //此时为Pi分配内存，以后不再分配！  
5.  **double** I=PI;               //编译期间进行宏替换，分配内存  
6.  **double** j=Pi;               //没有内存分配  
7.  **double** J=PI;               //再进行宏替换，又一次分配内存！

const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象\#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而\#define定义的常量在内存中有若干个拷贝。

**(5) 提高了效率**  
编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

**二. 使用 const**  
**(1) 修饰一般常量，常数组，常对象**  
修饰符const可以用在类型说明符前，也可以用在类型说明符后。 例如：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  //常量  
2.  **int** **const** x=2;  
3.  **const** **int** x=2;  
4.    
5.  //常数组  
6.  **int** **const** a\[5\]=\{1, 2, 3, 4, 5\};  
7.  **const** **int** a\[5\]=\{1, 2, 3, 4, 5\};  
8.    
9.  //常对象  
10. **class** A;  
11. **const** A a;  
12. A **const** a;

**(2) 修饰指针**

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **const** **int** \*A;     
2.  **int** **const** \*A; //const修饰指向的对象，A可变，A指向的对象不可变  
3.  **int** \***const** A; //const修饰指针A，     A不可变，A指向的对象可变   
4.  **const** **int** \***const** A; //指针A和A指向的对象都不可变

<<effective C++>>上有个好记的方法： const在\*号左边修饰的是指针所指的内容；const在\*号右边修饰的 是指针。  
简单记就是：左内容，右指针。

也可以这样理解：先忽略类型名，然后看const离哪个近，就修饰谁。

如：const \[int\] \*p; //先去掉int，这时const 修饰\*p, p是指针，\*p是指针指向的对象，不可变

**(3) 修饰引用**

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **const** **double** & v; //该引用所引用的对象不能被更新

**(4) 修饰函数的返回值**

const修饰符也可以修饰函数的返回值，返回值不可被改变，格式如下：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **const** **int** Fun1();  
2.    
3.  **const** MyClass Fun2();

**(5) 修饰类的成员函数**  
const修饰符也可以修饰类的成员函数，格式如下：

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** ClassName   
2.  \{  
3.  **public**:  
4.  **int** Fun() **const**;  
5.  .....  
6.  \}；

这样，在调用函数Fun时就 不能修改类里面的数据。

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  **public**:  
4.   A(**int** i=0):test(i) \{\} //初始化列表  
5.  **private**:  
6.   **const** **int** i

**(6) 在另一连接文件中引用const常量**

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **extern** **const** **int** i;     //正确的引用  
2.    
3.  **extern** **const** **int** j=10;  //错误！常量不可以被再次赋值

**三. 几个要说明的问题**  
**(1) 如何初始化类内部的常量?**  
方法1：初始化列表：

**\[cpp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  **public**:  
4.      A(**int** num):i(num) //用num来初始化i  
5.      \{\};  
6.    
7.  **private**:  
8.      **const** **int** i;  
9.  \};

方法2： 外部初始化

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  **public**:  
4.   A() \{\}  
5.  **private**:  
6.   **static** **const** **int** i;   //注意必须是静态的  
7.  \}；  
8.  **const** **int** A::i=3;  //外部初始化

**(2) 放在类内部的常量有什么限制？**

**\[cpp\]**  [view plain][] [copy][view plain]

1.  //error  
2.  **class** A  
3.  \{  
4.  **public**:  
5.    A()  
6.    \{\};  
7.    
8.  **private**:  
9.    **const** **int** c1 = 7;          //error  
10.   **static** **const** **int** c2 = 7;   //error  
11.     
12.   **static** **int** c3 = 7;         //error  
13. \}  
14.   
15.   
16. //correct  
17. **class** A  
18. \{  
19. **public**:  
20.   A(**int** num):c1(num)  
21.   \{\};  
22.   
23. **private**:  
24.   **const** **int** c1;  
25.   **static** **const** **int** c2;  
26.     
27.   **static** **int** c3;  
28. \}  
29. **const** **int** A::c2 = 7;  //不要加static  
30. **int** A::c3 = 7;        //不要加statci

这里是三种正确的初始化方法，要注意的是static在外部初始化时，不能再加上static标志。

**3) const到底是不是一个重载的参考对象?**  
先看一个例子：

**\[c-sharp\]**  [view plain][] [copy][view plain]

上面是重载是没有问题的了，那么下面的呢？

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  ......  
4.  **void** f(**int** i)       \{......\} //一个函数  
5.  **void** f(**const** **int** i) \{......\} //？？？  
6.  ......  
7.  \};

这是个错误的，编译不通过。那么是不是说内部参数的const不予重载呢？

再看下面的例子：

**\[c-sharp\]**  [view plain][] [copy][view plain]

1.  **class** A  
2.  \{  
3.  ......  
4.  **void** f(**int**&)       \{......\} //一个函数  
5.  **void** f(**const** **int**&) \{......\} //？？？  
6.  ......  
7.  \};

这个程序是正确的，看来上面的结论是错误的。为什么会这样呢？这要涉及到接口的透明度问题。  
按值传递时，对用户而言，这是透明的，用户不知道函数对形参做了什么手脚，在这情况下进行重载是没有 意义的，所以规定不能重载！

当指针或引用被引入时，用户就会对函数的操作有了一定的了解，不再是透明的了，这时重载是有意义的，所以规定可以重载。

[view plain]: http://blog.csdn.net/lwbeyond/article/details/6187501#