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

心已赠人 2022-08-09 03:25 226阅读 0赞

想当初面试时，面试官问我熟悉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;//一直指向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;

（再强调一下：我们说的常量指针与C++primer上的const指针是相反的概念，大家理解就好）

**第五部分**：**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去内存读取数据，这里不讨论）

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

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

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

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

void TestNoConst(int *Num)
    {
    	cout<<*Num;
    }
    const int constNum = 21;
    const int* pConst = &constNum;
    TestNoConst(pConst);//错误，形参不兼容	cout<<*Num;
    }
    const int constNum = 21;
    const int* pConst = &constNum;
    TestNoConst(pConst);//错误，形参不兼容

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

void TestNoConst(int *Num)
    {
    	cout<<*Num;
    }
    const int* GetNum(int *Num)
    {
    	return Num;
    }
    int constNum2 = 21;
    const int* pConst = GetNum(&constNum2);
    TestNoConst(pConst);

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

class ConstTestClass
    {
    public:
    
    	ConstTestClass(void)
    	{
    	}
    
    	~ConstTestClass(void)
    	{
    	}
    
    	void ReadMyNum() const
    	{
    		//SetMyNum();错误
    		((ConstTestClass*)(this))->SetMyNum();
    		const_cast<ConstTestClass*>(this)->SetMyNum();
    	}
    	void SetMyNum()
    	{
    		MyNum++;
    	}
    
    	int MyNum;
    };

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