Const用法总结(快速区分指针常量与常量指针)

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u012999985/article/details/49009531

想当初面试时,面试官问我熟悉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;

(再强调一下:我们说的常量指针与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对象后然后去修改他,那样其实可能会出问题。我们一般只是为了解决上面说的两种情况。
 


 

 

阅读更多

扫码向博主提问

Jerish_C

博客专家

非学,无以致疑;非问,无以广识
去开通我的Chat快问

没有更多推荐了,返回首页