C++中的const关键字

定义

const可以被称为伪关键字，因为它在改变生成代码方面做不了什么，有点像类和结构体的可见性，这是一个机制，让代码更干净，并对开发人员写代码强制特定的规则

const基本上就像你做出的承诺，承诺某些东西将是不变的，然而，它只是一个你可以绕过的承诺，可以打破。

如果它们实际上没有修改类或者它们不应该修改类，总是标记你的方法为const,否则在有常量引用或者类似的情况下就用不了你的方法。

未使用const关键字

const int MAX_AGE = 90; // 需要在程序中保持不变的数字

int* b = new int; //在堆上创建一个整数，这样就能得到一个指针
*b = 2;// 1、可以改变指针的内容即指针指向内存的内容
//重新分配实际的指针,这样就会指向别的东西，绕开const限制，将它强制转换成int*类型
b = (int*)&MAX_AGE; // 重新分配了指针指向，2、改变指针指向的地址
cout << *b << endl;

1、可以改变指针指向内存的内容

2、能够重新分配指针指向，改变指针指向的地址

Const关键字用法

const在*前面

const int a = 5; // 加入const后，已经从语法上指定了这个整数是一个常数，并且不打算修改

const int* c = new int;// 意味着不能修改指针指向的内容
//int const* c = new int;// 两个表达式是一样的
//*c = 2; // 逆向引用不能改变内容
c = (int*)&a;  //可以改变指针指向的地址
cout << *c << endl; // c的值是实际内存地址上的内容,读取c没问题

const int a = 5;加入const，承诺这个整数时一个常数，并不打算修改

const int* c = new int;意味着不能修改指针指向的内容，但是可以修改指针指向的地址，重新分配指针指向。与int const* c = new int;表达式等价

const在*后面，函数名前

const int M = 6;

int* const d = new int;
*d = 2; // 可以改变指针指向内存的内容
//d = (int*)&M; // 不能把实际的指针本身重新赋值，指向别的东西，不能重新分配指针指向

int* const d = new int;可以改变指针指向内存的内容，但是不能把实际的指针重新赋值，不能重新分配指针指向。

const在*前后都存在

const int* const e = new int;
// 意味着不能改变指针指向内存的内容，同时也不能重新分配指针指向

意味着不能改变指针指向内存的内容，同时也不能重新分配指针指向

const在类中的用法

它与变量无关，而是在方法名之后，并且这只在类中有效，这意味着这个方法不会修改任何实际的类，因此可以看到我们不能修改类成员变量。

class Entity
{
private:
	int m_X, m_Y;
	int* m_T, *m_E;// *放到int类型旁边，m_X就是一个指针，m_Y仍然是一个int整型，如果要同一行都是指针，需要在变量旁边加上*
public:
	int GetX() const  // const的第三种用法，它与变量无关，而是在方法名之后，并且这只在类中有效，这意味着这个方法不会修改任何实际的类，因此可以看到我们不能修改类成员变量
	{
	
		//m_X = 2;  // 承诺这个方法不会修改实际的类，只能是读，不能写
		return m_X;
	}
	int GetX()
	{
		return m_X;
	}
	const int* const Get() const // 这意味着我们返回了一个不能被修改的指针，指针的内容也不能被修改，这个方法承诺不修改实际的Entity类
	{
		return m_T;
	}
	void SetX(int x) // 不能在这里声明const,因为这个类要修改
	{
		m_X = x;
	}
};

void PrintEntity(const Entity* m) //可以重新分配指针指向，但不能修改指针内容
{
	m = nullptr;
	cout << m->GetX() << endl;
}
void PrintEntity1(const Entity& m) 
//意味着当我调用const Entity时，我可以调用任何const函数
{
	//m = Entity(); // 不能将它重新赋值，与指针工作方式不同，重新分配这个引用，实际上是在改变这个对象e，它没有指针本身和指针指向内容的区别，因为引用就是内容，这就是你能修改的
	cout << m.GetX() << endl; //当有两个GetX时，它会自动调用符合条件的方法
}

int* m_T, *m_E; *放到int类型旁边，m_X就是一个指针，m_Y仍然是一个int整型，如果要同一行都是指针，需要在变量旁边加上*。

const放在函数名后面表示：承诺这个方法不会修改实际的类，只能是读，不能写。

const int* const Get() const ; 这意味着我们返回了一个不能被修改的指针，指针的内容也不能被修改，这个方法承诺不修改实际的Entity类。

void PrintEntity(const Entity* m)  可以重新分配指针指向，但不能修改指针内容。

void PrintEntity1(const Entity& m) 意味着当我调用const Entity时，我可以调用任何const函数。m = Entity();不能将它重新赋值，引用与指针工作方式不同。重新分配这个引用，实际上是在改变这个对象m，它没有指针本身和指针指向内容的区别，因为引用就是内容，这就是你能修改的

什么是mutable关键字？

mutable 允许函数是常量方法，但可以修改变量。某种情况下，确实想要标记方法为const,但是由于某些原因，它又确实需要修改一些变量。

class Entity
{
private:
	int m_X, m_Y;
	int* m_T, *m_E;// *放到int类型旁边，m_X就是一个指针，m_Y仍然是一个int整型，如果要同一行都是指针，需要在变量旁边加上*
	mutable int var;
public:
	int GetX() const  // const的第三种用法，它与变量无关，而是在方法名之后，并且这只在类中有效，这意味着这个方法不会修改任何实际的类，因此可以看到我们不能修改类成员变量
	{
		var = 2;
		//m_X = 2;  // 承诺这个方法不会修改实际的类，只能是读，不能写
		return m_X;
	}

完整代码 

# include <iostream>
using namespace std;

class Entity
{
private:
	int m_X, m_Y;
	int* m_T, *m_E;// *放到int类型旁边，m_X就是一个指针，m_Y仍然是一个int整型，如果要同一行都是指针，需要在变量旁边加上*
	mutable int var;
public:
	int GetX() const  // const的第三种用法，它与变量无关，而是在方法名之后，并且这只在类中有效，这意味着这个方法不会修改任何实际的类，因此可以看到我们不能修改类成员变量
	{
		var = 2;
		//m_X = 2;  // 承诺这个方法不会修改实际的类，只能是读，不能写
		return m_X;
	}
	int GetX()
	{
		return m_X;
	}
	const int* const Get() const // 这意味着我们返回了一个不能被修改的指针，指针的内容也不能被修改，这个方法承诺不修改实际的Entity类
	{
		return m_T;
	}
	void SetX(int x) // 不能在这里声明const,因为这个类要修改
	{
		m_X = x;
	}
};


int main()
{
	Entity m;
	const int a = 5; // 加入const后，已经从语法上指定了这个整数是一个常数，并且不打算修改
	const int M = 6;
	const int MAX_AGE = 90; // 需要在程序中保持不变的数字
	//a = 2;
	int* b = new int; //在堆上创建一个整数，这样就能得到一个指针
	*b = 2;// 1、可以改变指针的内容即指针指向内存的内容
	//重新分配实际的指针,这样就会指向别的东西，绕开const限制，将它强制转换成int*类型
	b = (int*)&MAX_AGE; // 重新分配了指针指向，2、改变指针指向的地址
	cout << *b << endl;
	const int* c = new int;// 意味着不能修改指针指向的内容
	//int const* c = new int;// 两个表达式是一样的
	//*c = 2; // 逆向引用不能改变内容
	c = (int*)&a;  //可以改变指针指向的地址
	cout << *c << endl; // c的值是实际内存地址上的内容,读取c没问题
	//使用const的第二种方式是将它放在*之后
	int* const d = new int;
	*d = 2; // 可以改变指针指向内存的内容
	//d = (int*)&M; // 不能把实际的指针本身重新赋值，指向别的东西，不能重新分配指针指向
	const int* const e = new int;
	// 意味着不能改变指针指向内存的内容，同时也不能重新分配指针指向
	//*e = 2;
	//e = (int*)&M;
	cout << *e << endl;
	cout << e << endl;
	cout << &e << endl;
	cin.get();
	return 0;
}