const关键字总结

const关键字

被const修饰的变量是不能改变的
const修饰变量时，必须在声明变量的同时给出初始化(类中的const成员变量不一样)

顶层const与底层const

顶层const

定义为变量本身是一个常量，因此对一切的内置类型常量而言，所有的const都是顶层const
对指针来说，常量指针是顶层const，对于引用则没有顶层const的概念。

底层const

只在指针和引用上有效，其定义是该指针指向或该引用绑定的对象是常量。
因此：顶层const和底层const，引用只有底层const。

int main()
{
	int a = 10;
	int aa = 100;

	const int *b = &a;	//底层const指针
	*b = 20;	//错误，底层const指针不可以修改指向的值
	b = &aa;	//正确，底层const指针可以指针的指向

	int * const c = &a;		//顶层const指针
	*c = 20;	//正确，顶层const指针可以修改指针指向的值
	c = &b;	//错误，顶层const指针不能修改指针的指向

	b = c;	//底层const指针可以指向顶层const指针(顶层const可以赋值给底层const)
	c = b;	//底层const指针不可以赋值给顶层const指针

	const int& e = a;	//引用的底层const
	e = 1000;	//错误，引用的底层const不能修改值

	const int* const f = &aa;	//同时被顶层和底层const封锁的指针既不能修改其指向，也不能修改其指向的内容

	return 0;
}

const与函数

成员函数后使用const

就不能对此方法生命周期外的变量值修改，可以保护成员变量不被方法修改

class Example
{
public:
    int getData() const
    {
        m_data = 100;    //错误，成员函数后使用const，不能对该方法生命周期外的变量值修改，保护了成员变量
        return m_data;
    }
private:
    int m_data;
};

函数成员前加const

保证在外部调用该方法后，返回值不会被篡改

class Example
{
public:
	const int* getData() const
	{
		return &m_data;
	}
private:
	int m_data;
};

int main(int argc, char* argv[])
{
	Example e;
	*e.getData()=100;	//错误，函数前加了是const，返回值不能被篡改
	return 0;
}

const与mutable

mutable 是为了突破 const 的限制而设置的。可以用来修饰一个类的成员变量。被 mutable 修饰的变量，将永远处于可变的状态，即使是 const 函数中也可以改变这个变量的值。

class Example
{
public:
	int getData() const
	{
		m_isdone = true;	//正确，被mutable修饰的类的成员变量，即使在被const修饰的成员函数中也能被修改
		return m_data;
	}
private:
	int m_data;
	mutable bool m_isdone;
};

const与类和对象

类的const对象只能调用类的const成员函数，类的非const对象可以调用const成员函数和非const成员函数

class Example
{
public:
	int getData() const
	{
		return m_data;
	}
private:
	int m_data;
};

int main(int argc, char* argv[])
{
	const Example e1;
	e1.getData();

	Example e2;	//正确，类的非const成员可以调用const成员函数和非const成员函数
	e2.getData();

	return 0;
}

不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const成员的值是什么。const数据成员的初始化只能在类构造函数的初始化表中进行！

class Example
{
public:
	Example(int data):m_data(data){}	//const成员的初始化只能在类构造函数的初始化表中进行
private:
	const int m_data;	//const成员
};

int main(int argc, char* argv[])
{
	Example e1(10);
	return 0;
}

想要在类中建立恒定的常量，应该用类中的枚举常量来实现。

class Example
{
public:
	Example():m_data(DATA1){}
private:
	enum {DATA1=100,DATA2=200};	//枚举常量成员
	int m_data;
};

int main(int argc, char* argv[])
{
	Example e1();
	
	return 0;
}

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数。

​