const用法总结

1.修饰变量

修饰变量表示该变量是不能改变的变量， 表明变量是常量

• const int N = 100;
• const double pai = 3.1415926;

比如下面的操作

N = 1;       // X
pai = 3.14   // X

上述操作是不能被允许的；

cout << N << " " << pai << endl;

上述操作是正常的

另外也可以将const放在类型后面：

• int const N = 100;
• double const pai = 3.1415926;

二者是一样的

2.修饰引用

定义变量

• int a = 3;
• const int b = 5;
• const int &c = a; c是变量a的引用指针，将c指针设定为const
• const int &d = b; d是const变量b的引用指针，将d指针设定为const

执行下面命令

a = 10;  	// V

c = 11; 	 // X  由于c指针是const指针，其值不能发生改变
int &e = b;  // X  e是一般引用，由于b是const常量，应该使用const int &e = b;

3.1修饰指针–常内容指针

常内容指针表明指针指向的内容是不能修改的，但指针是可以修改的，样式如下：

const char &pContent;

常内容：

• char s1[100], s2[100];
• const char *pContent = s1;

执行下面操作

• pContent = s2; V 该操作是可以的，指针的值是可以修改的
• pContent[0] = 'a', *pContent = 'a'; X 该操作是不可以的

因为pContent指向的内容是const常内容，不能通过指针的方式去修改常内容中的单个字符

等价写法：

• const (char) *pContent;

3.2 修饰指针–常指针

常指针表明该指针是固定的，不能进行修改，指向的内容是可以进行修改，样式如下：

• char * const pContent;
• pContent是常量

常指针：

• char s1[100], s2[200];
• char * const pContent = s1;

执行下面的操作：

• *pContent = 'a'; V 该操作是允许的，能够改变常指针指向的内容
• pContent=s2; X 该操作是不允许的，不能够改变常指针

等价写法：

• (char *) const pContent;
• const (char *) pContent;

3.3 两者都不可变，常内容，常指针

两者都不可变表示指针不能改变，指针指向的内容也不能改变，样式如下：

• const char * const pContent;

例子：

• char s1[100] = "1 2 3 4", s2[100];
• const char * const pContent = s1;

执行以下操作：

• s1[0] = 'a', s2[0] = '1'; V 该操作是允许的，因为s1和s2是字符串变量，能够对s1和s2进行改变操作
• pContent[0] = 'x'; X 该操作是不允许的，因为pContent是const指针，且其指向的内容也是const限定，不能进行修改
• pContent = s2; X 该操作是不允许的，因为pContent是const指针，且其指向的内容也是const限定，不能进行修改
• cout << s1; cout << s2; V 该操作是允许的

4. 修饰函数

4.1 出现在返回值前面

出现在返回值前面表明该函数返回值是const常量， 样式如下：

• const int fun1();

int a; a = fun1(); V： 因为int本身就是常量，因此可以直接
const int b = fun1(); V

• const int *fun2(int &a); // 返回常内容指针

int *q, c = 5;
const int *pValue;
pValue = fun2©; V: 因为pValue是常内容指针
q = fun2©; X: 因为q是普通指针，不是常内容指针，不能保证指向的内容不被修改

• int * const fun3(int &a); // 返回常指针

int a = 6;
int * const pValue = fun3(a); V
const int *r = fun3(a); V
int *q = fun3(a); V

4.2 const 出现在形参中

const出现在形参中表明该参数是常量

• fun(const int N, int * const q, const int *p);

例子：
int fun4(const int a);

int fun4(const int a)
{
	int b;
	b = a+1;
	// a = a + 1;  X 因为a是常量，可以被使用，但是不能被修改
	return a + b;
}

5. const修饰类对象/对象指针/对象引用

假设POINT是一个类

• const POINT a; // 常量对象

• const POINT *p; // 常对象的指针

• POINT * const r; // 常量指针

• POINT b;

• const POINT &c = b; // 常引用

• 常量对象，这个对象的所有成员都不能修改

• 常引用，不能通过这个引用名修改对象的成员

const POINT x; 与 const int a;有所不同

• const修饰对象：
  • 只能调用对象的const成员函数
  • 不能调用非const成员函数
  • 因为非const成员函数会有修改成员变量的企图

例子：

class POINT
{
	int x, y;
	public:
		POINT(int a, int b)
		{
			x = a;
			y = b;
		}
		
		void f1();
		void f2() const;  // const 成员函数
};

void POINT::f1()
{
	x = 11, y = 12;   // V 该操作是允许的
	cout << "function 1\n";
}

void POINT::f2() const
{
	// x = 21, y = 22;  // X 该操作是不允许的
	cout << "function 2\n";
}

主函数测试

int main()
{
	const POINT b(1, 2);
	POINT c(3, 4);
	c1.f1();  // V 该操作是允许的
	c2.f2();  // V 该操作是允许的

	b.f1();   // X 该操作是不允许的，因为f1不是const成员函数，b是常量对象
	b.f2();   // V 该操作是允许的，因为f2是const成员函数

	const POINT *p = new POINT(5, 6);
	p -> f1();  // X 该操作是不允许的
	p -> f2();  // V 该操作是允许的
	return 0;
}

后缀const的函数
不能改变对象的成员变量.
也不能调用类中任何非const成员函数

6.const类修饰类的成员变量

const修饰类的成员变量，表示成员常量，不能被修改，同时它只能在初始化列表中赋值。

class A
{
	private:
		const int Value;  // 成员常量不能被修改
	public:
		A(int x): Value(x)
		{
			Value = 10;  // X 该操作是不被允许的，因为只能在初始化的时候被赋值
		}
}

总结

const是对程序加了一些限制，防止编码的时候出现一些问题，但是去掉const并不影响程序正常运行，加const是一个好的习惯。

• int a, b, d[100]
• const int N=10; // 常量，值不能改
• const int *p; // 常内容指针，指向的单元的内容不能改
• int * const q=d; // 常指针, 指针的值不能改,不能再指向其它单元
• const int &c=a; // 常引用,不能通过常引用修改其值
• const POINT x; // 常量对象，只能访问常成员函数
  • 常成员函数，不能修改数据成员的值，也不能访问非const成员函数
  • 常成员，只能在构造函数头部初始化