const 在基本语言中的总结

最新推荐文章于 2021-12-21 13:25:27 发布

big_bit

最新推荐文章于 2021-12-21 13:25:27 发布

阅读量461

点赞数 1

分类专栏： C/C++ 语言文章标签： const c++ 语言

C/C++ 语言专栏收录该内容

51 篇文章 4 订阅

订阅专栏

一、Const作用

如下表所示：

No.	作用	说明	参考代码
1	可以定义const常量		const int Max = 100;
2	便于进行类型检查	const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误	void f(const int i) { .........} //对传入的参数进行类型检查，不匹配进行提示
3	可以保护被修饰的东西	防止意外的修改，增强程序的健壮性。	void f(const int i) { i=10;//error! } //如果在函数体内修改了i，编译器就会报错
4	可以很方便地进行参数的调整和修改	同宏定义一样，可以做到不变则已，一变都变
5	为函数重载提供了一个参考		class A { ...... void f(int i) {......} //一个函数 void f(int i) const {......} //上一个函数的重载 ...... };
6	可以节省空间，避免不必要的内存分配	const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝	#define PI 3.14159 //常量宏 const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... double i=Pi; //此时为Pi分配内存，以后不再分配！ double I=PI; //编译期间进行宏替换，分配内存 double j=Pi; //没有内存分配 double J=PI; //再进行宏替换，又一次分配内存！
7	提高了效率	编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高

二、Const的使用

1.const对象默认为文件的局部变量

· 在全局作用域声明的const变量是定义该对象的文件的局部变量。此变量只存在于那个文件中，不能被其他文件访问。

· 要在其他文件中访问const变量，可以通过指定const变量为extern，就可以在整个程序中访问const对象。

比如：

const_basic_stdy.h
#ifndef _COSNT_BASIC_STDY_H_
#define _COSNT_BASIC_STDY_H_
extern const int con_glob_int;
extern const int con_glob_int1;
#endif
 
const_basic_stdy.cpp
#include "const_basic_stdy.h"
 
const int con_glob_int = 10;
 
extern const int con_glob_int1 = 110;

· 非const变量的定义默认为extern。要使const变量能够在其他文件中访问，必须在文件中显式地指定它为extern。

2. const 引用

· 非const引用只能绑定到与该引用相同类型的对象。 const引用则可以绑定到不同但相关的类型的对象或绑定到右值。比如：

       int i = 42;
       //  legal for constreferences only
       constint &r = 42;
       constint &r2 = r + i;

3.const 头文件

· 一般来说，常量表达式是编译器在编译时就能够计算出结果的表达式。当 const 整型变量通过常量表达式自我初始化时，这个 const 整型变量就可能是常量表达式。而 const 变量要成为常量表达式，初始化式必须为编译器可见。为了能够让多个文件使用相同的常量值，const 变量和它的初始化式必须是每个文件都可见的。而要使初始化式可见，一般都把这样的 const 变量定义在头文件中。那样的话，无论该 const 变量何时使用，编译器都能够看见其初始化式。

· 但是，C++ 中的任何变量都只能定义一次（第 2.3.5节）。定义会分配存储空间，而所有对该变量的使用都关联到同一存储空间。因为const 对象默认为定义它的文件的局部变量，所以把它们的定义放在头文件中是合法的。

· 当该 const 变量是用常量表达式初始化时，可以保证所有的变量都有相同的值。但是在实践中，大部分的编译器在编译时都会用相应的常量表达式替换这些const 变量的任何使用。所以，在实践中不会有任何存储空间用于存储用常量表达式初始化的 const 变量。

· 如果 const 变量不是用常量表达式初始化，那么它就不应该在头文件中定义。相反，和其他的变量一样，该const 变量应该在一个源文件中定义并初始化。应在头文件中为它添加 extern 声明，以使其能被多个文件共享。

//a.h
extern const int num;
//a.cpp
#include "a.h"
#include <stdlib.h>
#include <time.h>  
 
int r(){
              srand(time(NULL));
              return rand() % 100;
}
 
const int num = r();
//main.cpp
#include "a.h"
#include<iostream>
using namespace std;
 
int main(){
              cout<<num<<endl;
}

首先要明白这个extern keyword的作用。

"extern"关键词的作用是将一个变量声明为外部链接，与其相对的是内部链接。C/C++编译模式，是以每个独立的文件（包括包含的头文件）作为一个独立的单元进行编译的，里面定义的变量都默认为内部链接。也就是说，在编译的时候，题中的a.cpp和main.cpp是各不知道互相的存在的。如果在a.h里声明一个变量：
const int a = 100;
那么，在编译的时候编译器会单独给a.cpp和main.cpp创建两个常量，而这两个常量因为是内部链接，它的符号只有在本编译单元内有识别性，在链接时其它的编译单元是看不到它们的定义的，于是这个a变量在编译时会被通过value propagation优化而内联到其它使用它的地方。

而extern关键词，就是把这个常量变成外部链接，也就是说，这个常量会在别的编译单元里变得可见（当然在任何一个编译单元里使用它都需要声明）。编译器不会优化它的内存地址，相反，编译器在输出符号表的时候会给它一个链接器可见的符号，那么链接器会将a.cpp和main.cpp中的intnum都指向同一个常量池中的地址。于是两个文件都有了同一个常量的引用。

于是，我们知道为什么extern常量的值仅且必须在其中一个.cpp文件中定义了--->这个常量在多个编译单元中共用一个相同的内存地址，只能初始化一次。

至于它的作用，如果两个编译单元需要共用一个常量，并且常量初始值不甚明了（如题中那样需要用rand求得时），那么可以使用extern常量。另外，在做库函数时extern还是非常常用的，比如用户调用库里声明定义的常量 --- 如果不声明为extern，根据上文所述，用户是无法看到这个常量的，于是也无法调用了。

4.const 和指针

const限定符和指针结合起来常见的情况有以下几种。

· 指向常量的指针（指向const对象的指针）

const double*cptr; // cptr may point to a doublethat is const

这里的cptr 是一个指向 double 类型 const 对象的指针，const 限定了 cptr 指针所指向的对象类型，而并非 cptr 本身。也就是说，cptr 本身并不是 const。在定义时不需要对它进行初始化，如果需要的话，允许给 cptr 重新赋值，使其指向另一个 const 对象。但不能通过 cptr 修改其所指对象的值：

*cptr = 42; // error: *cptr might be const

允许把非const对象的地址赋给指向const对象的指针：

double dval = 3.14; //dval is a double; its value can be changed

cptr = &dval; // ok: but can't change dval throughcptr

· const 指针

除指向 const 对象的指针外，C++ 语言还提供了 const 指针——本身的值不能修改。与任何 const 量一样，const指针也必须在定义时初始化。

5. const修饰函数参数
a.传递过来的参数在函数内不可以改变(无意义，因为Var本身就是形参)

void function(const int Var);

b.参数指针所指内容为常量不可变

void function(const char* Var);

c.参数指针本身为常量不可变(也无意义，因为char* Var也是形参)

void function(char* const Var);

d.参数为引用，为了增加效率同时防止修改。修饰引用参数时：

void function(const Class& Var); //引用参数在函数内不可以改变

void function(const TYPE& Var); //引用参数在函数内为常量不可变

这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的,他禁止对引用的对象的一切修改,唯一不同的是按值传递会先建立一个类对象的副本, 然后传递过去,而它直接传递地址,所以这种传递比按值传递更有效.另外只有引用的const传递可以传递一个临时对象,因为临时对象都是const属性, 且是不可见的,他短时间存在一个局部域中,所以不能使用指针,只有引用的const传递能够捕捉到这个家伙.

(2)const 修饰函数返回值
const修饰函数返回值其实用的并不是很多，它的含义和const修饰普通变量以及指针的含义基本相同。
a.const int fun1() //这个其实无意义，因为参数返回本身就是赋值。

b.const int * fun2() //调用时 const int *pValue = fun2();
//我们可以把fun2()看作成一个变量，即指针内容不可变。

c.int* const fun3() //调用时 int * constpValue = fun2();
//我们可以把fun2()看作成一个变量，即指针本身不可变。

一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（constA test = A 实例）或某个对象的引用为const（const A& test = A实例），则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。

三、将Const类型转化为非Const类型的方法

采用const_cast 进行转换。
用法：const_cast <type_id> (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。

· 常量指针被转化成非常量指针，并且仍然指向原来的对象；

· 常量引用被转换成非常量引用，并且仍然指向原来的对象；

· 常量对象被转换成非常量对象。

四、使用const的一些建议

· 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；

· 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；

· 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；

· const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；

· 不要轻易的将函数的返回值类型定为const;

· 除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;