C++中const关键字的使用

const是英文constant的缩写，意思为不变的、恒定的。const是C++中的一个关键字，它限定一个变量不允许被修改，使用const在一定程度上可以提高程序的安全性和可靠性。

1. 修饰局部变量

const int a = 10;
int const a = 10;
a = 5;	// 非法，不能赋值

上面两种写法是等价的，定义了a为一个常量，值为10，并且a的值不能被修改，所以，const在修饰变量时，在声明变量时要进行初始化，否则之后无法赋值。

2. 常量指针和指针常量

常量指针指的是指针指向的内容是常量，表示该指针指向的内存空间只读，但是其指针变量可被修改。

const int *p ;
int const *p ;// 两种写法等价

注意，指针指向的内存空间不能改变，但是指针可以指向其他地址。

int a = 10;
const int *p = &a;
cout<<*p<<endl;	// 输出10
*p = 5;	// 非法，不能赋值
int b = 15;
p = &b;	// 合法，p重新指向b
cout<<*p<<endl;	// 输出15

指针常量指的是指针本身是个常量，不能在指向其他地址，表示该指针变量不能被修改，但该指针指向的内存空间可以被修改。

int* const p;

注意，指针常量指向的地址不能改变，但指针指向的内存空间是可以改变的，可以通过其他指向该内存空间的指针来修改。

	int a=5;
	int* const p=&a;
	cout<<*p<<endl;	// 输出结果为5
	int b=10;
	p = &b;	// 非法，不能赋值
	*p=b;	// 合法，p指向的内存空间的值被修改为10，同时a的值被修改为10
	cout<<*p<<endl;	// 输出结果为10
	cout<<a<<endl;	// 输出结果为10
	int* n=&a;
	*n=20;	// 通过另一个指向a的指针n修改n指向的内存空间的值，则a的值和p指向的内存空间的值同时为修改为20
	cout<<*p<<endl;	// 输出结果为20
	cout<<a<<endl;	// 输出结果为20

还有一种情况是上两种情况同时出现，即const int * const p = &a，这时候指针p指向的地址不能改变，且指向的内存空间也不能改变。

int a = 5;
const int* const p = &a;
cout<<a<<endl;	// 输出结果为5
cout<<*p<<endl;	// 输出结果为5
int b = 10;
p = &b;	// 非法，不能赋值
*p = b;	// 非法，不能赋值

3. 修饰成员函数

const在函数名的前面，此时const修饰的是函数的返回值，一般是用于修饰返回值为指针的情况。
const在函数名的后面，此时const修饰的是常成员函数，即该函数是“只读”的状态，不能修改对象内任何成员的值。

#include <iostream>
using namespace std;
class Myclass
{
public:
	Myclass(int, int*);
	int getA() const;
	const int* getP();
private:
	int m_a;
	int *m_p;
};
Myclass::Myclass(int a,int* p)
{
	m_a = a;
	m_p = p;
}
int Myclass::getA() const
{
	m_a = 5;	// 非法，const修饰成员函数，不能修改对象中任何成员的值。
	return m_a;
}
const int* Myclass::getP()
{
	return m_p;
}

int main()
{
	int a = 10;
	int b = 15;
	int c = 20;
	int *p = &b;
	int *ptr1;
	const int *ptr2;
	Myclass T1(a,p);
	c = T1.getA();
	ptr1 = T1.getP();	// 非法，getP()前加了const进行修饰，函数返回值为“只读”，只能幅值为常量指针
	ptr2 = T1.getP();	// 合法，ptr2为常量指针，指向的空间的值“只读”
	cout<<c<<endl;	// 输出结果为10
	cout<<*ptr1<<endl;	// 非法，ptr1并没有被赋值，没有指向任何空间
	cout<<*ptr2<<endl;	// 输出结果为15
	return 0;
}

注：欢迎转载，转载请注明出处，谢谢！