Const用法总结（快速区分指针常量与常量指针）

想当初面试时，面试官问我熟悉C++么？熟悉的话说一下const的用法，然后我就开始凌乱了~

 

其实const的用处还真不少，好好捋顺一下会有很大的帮助。

有时候我们希望定义一种常量，它的值不能被修改，这个常量既可以防止程序其他地方不小心修改这个值，也能让程序员比较方便的调整这个值的大小。

以往我们很容易想到#define宏定义，现在使用const是个更为不错的选择，因为它有类型，可以进行类型检查。

 

第一部分：const的初始化

Const值一旦创建后就不能修改，所以const对象必须初始化。

Const int i=0;//正确

Constint i;//错误

 

Const对象可以用非const对象初始化，也可以付给非const对象，同时也能参与运算，只要初始化后不改变它的值就没问题。

Int i;

Constint j=i;//正确

Intm=j;//正确

 

第二部分：const的作用域

默认状态下，Const对象仅在文件内有效。所以不同文件的const对象不是同一个对象，即使名字相同，因为这样才能避免重复定义。

那为了使一个非常量表达式的const变量在不同文件之间可以共享，可以使用extern来解决问题。

我们知道关键字extern可以用作对象的声明而不定义。所以我们按如下的方式：

//file.cpp

extern constint temp=fun();

//file.h

extern constint temp;//正确

 

第三部分：const与引用

引用可以节省拷贝带来的内存损耗。类似起了个别名。

1.      对常量的引用必须要用const引用

Const int c=42;

Int &r1=c;      //错误，因为非常量引用可以改变所引用对象，所以这样不合理

Const int&r2=c;//正确，引用与对应的对象都是常量

2.      对const的引用可能并非引用一个const对象

int a=0;

int &r1=a;

const int&r2=a;//正确

r1=0;

r2=0;         //错误，r2是常量引用不能修改所引用的值

3.      初始化常量引用时允许用任意表达式（可以是不同类型）作为初始值

Int i=4;

Double b=9.22;

Const int &r1=i;

Const int &r2=b;

Const int&r3=44;

Const int&r4=r1*2;

//以上都是正确的

int &r5=r1*2;     //错误,r5是普通的非常量的引用

 

 

第四部分：const与指针

1.      与常量引用相似，指向常量的指针必须要用const指针（指向常量的指针）

const int c=42;

int *r1=&c;      //错误

const int*r2=&c;//正确

*r2=42;//错误，不能给指针所指对象赋值

2.  常量指针（指向const的指针）和指针常量（const指针）

区分常量指针（指向常量的指针）和指针常量（地址是常量，指针指向的地址不变）

（前两个字作为形容词修饰后两个字。

同时大家也要注意const指针这一说法，不要理解成常量指针）

Int num=0;

Int*const cur=#//一直指向num

Const double pi=3.1415;

Const double * const pip=π//指向常量的常量指针。

 

*现在举例子说明一下常量指针域指针常量到底如何区分。

1. int const* cur;   常量指针，指向常量的指针

2.Const int * cur;   常量指针，指向常量的指针

3. int*const cur;   指针常量

4. const(int *) cur;  //错误，不可以这么写

 

现在我们可以以*为分界，我们从右向左读取指针变量（cur）最近的关键字，1和2的情况变量紧挨着*（理解为*直接修饰cur），证明该指针不是常量指针，而3中const比*更接近变量，所以3是常量指针（理解为*修饰const  cur ，const修饰cur，所以cur是不变的）

这里记忆的方法并不是深入C++原理的方法，不过个人觉得非常有效！！！强烈建议试试！！

 

虽然没有第四种情况，但是在使用typedef时有一个类似的情况，这里在给出一个例子。

typedef  char* pstring;

const  pstring cstr=0;

//cstr是一个指向char的常量指针，这句话等价于char*  Const  cstr=0;

//而不是等价于Const  char*  cstr=0;

 

第五部分：const与函数参数

1.       顶层const与底层const

带有const声明的变量本身不变是顶层const，所引用或所指向的对象不变就是底层const。

在进行拷贝操作时，顶层const一般可以忽略，但是底层const不可以忽略。

2.      实参初始化形参时会忽略顶层const

Void fun(const inti)

Void fun(int i)//再次定义则会报错，重复定义，二者其实没什么差别，因为第一个顶层const被忽略

3.      形参的初始化方式和变量的初始化方式一样，可以使用非常量初始化一个底层const，但反过来不

可以

Int i=0;

Const int &j=i;//正确

Int &r1=j;//错误

同理，对于函数int  reset(int *a){}

Int i=0;

Const int ci=i;

Reset(&i);//正确

Reset(&ci);//错误

4.      尽量使用常量引用

把函数不会改变的形参定义成普通引用会造成一种可以改变的错觉，而且限制了实参的类型。因为我们上面说了，常量引用可以接受更多种类的赋值，包括表达式，字面值等。有时，还可能出现把常量引用作为参数赋给非常量引用的错误。

下面是C++primer里面的两个例子(有修改，这里不在意功能)：

例1：

Int find_char(string&s,char c)

Find_char(“Hello”,’o’);//错误，普通引用无法接收字面值

例2：

Bool  isSentence(const string &s)

{

   Return find_char(s,’o’);//错误，s是常量引用不能赋给非常量变量

}

 

 

第六部分：const与类

1.      const成员变量

类中声明变量为const类型。但是不可以初始化，必须要在构造函数初始化列表中初始化。

这样的变量其实只是在一个对象中是不变的，要想在整个类中都不变就得用enum（枚举）

2.      const成员函数

这样的成员函数不可以修改数据成员，如果修改成员变量或者调用了其他非const成员函数就会报错。

第七部分：const_cast的理解

C风格的强转大家应该都会使用 ，如  （int*）a；

但是这样的强转不会做任何安全检查，很有可能出现强转成一个野指针，造成崩溃。所以C++，针对不同的情况给处理几种特殊的强转符号

const_cast

dynamic_cast

static_cast

reinterpret_cast

这里我们关注const_cast。

首先，const_cast时做什么的？为什么要使用const_cast？

const_cast可以帮助我们移除变量（必须是指针或者引用）的const或volatile限定符。（volatile 是强制cpu去内存读取数据，这里不讨论）

1. const int constNum = 21;
2. const int* pConst = &constNum;
3. int* modifier = const_cast< int*>(pConst); //int* modifier1 = (int*)(pConst);//可以，这里操作是安全的
4. //int* modifier2 = pConst; //错误，提示无法从“const int *”转换为“int *”
5. //int *pConst2 = &constNum;//编译错误，const int*不能初始化int*
6. int constNum2 = 21;
7. int *pConst2 = &constNum2;
8. pConst = &constNum2; //合法，非const指针可以赋值给const指针

从上面的代码我们可以看到我们无法将一个const类型的指针赋给一个普通类型的指针，而非const的指针却可以给const指针赋值。所以将一个const类型的指针赋给一个普通类型的指针时我们需要const_cast来帮助我们正确的进行赋值（见modifier）

那么都有什么情况下我们需要使用const_cast呢？

1.函数的参数是一个非const类型，但是我们目前得到的参数是一个const类型

1. void TestNoConst(int *Num)
2. {
3. cout<<*Num;
4. }
5. const int constNum = 21;
6. const int* pConst = &constNum;
7. TestNoConst(pConst); //错误，形参不兼容

下面这种情况可能更为常见，我们使用别人提供的函数，一个返回const，另一个却又不接受

1. void TestNoConst(int *Num)
2. {
3. cout<<*Num;
4. }
5. const int* GetNum(int *Num)
6. {
7. return Num;
8. }
9. int constNum2 = 21;
10. const int* pConst = GetNum(&constNum2);
11. TestNoConst(pConst);

2.在被const修饰的函数里面调用非const函数

1. class ConstTestClass
2. {
3. public:
4. 
   
5. ConstTestClass( void)
6. {
7. }
8. 
   
9. ~ConstTestClass( void)
10. {
11. }
12. 
    
13. void ReadMyNum() const
14. {
15. //SetMyNum();错误
16. ((ConstTestClass*)( this))->SetMyNum();
17. const_cast<ConstTestClass*>( this)->SetMyNum();
18. }
19. void SetMyNum()
20. {
21. MyNum++;
22. }
23. 
    
24. int MyNum;
25. };

不过有一点要知道，const_cast的目的并不是用来强制改变const对象后然后去修改他，那样其实可能会出问题。我们一般只是为了解决上面说的两种情况。