1.为什么需要将数据定义为只读的？

• C++有不少措施保护数据的安全性， 如private保护类的数据成员等。但对于一些共用的数据， 如函数实参与形参等， 我们可以在不同的场合通过不同的途径访问同一个数据对象。 有时不经意的误操作会改变数据的值， 而这是人们所不希望出现的。
• 既要使数据能在函数间共享， 又要保证它不被任意修改， 可以使用const限定， 即把数据定义为只读的。

2.常对象

• 在定义对象时使用const限定， 称它为常对象， 定义的一般形式为：

类名 const 对象名1(实参列表), 对象名2,......;
或者
const 类名 对象名1(实参列表), 对象名2,......;

eg：如已定义Data类， 定义常对象如下：
const Data d1; //定义常对象
Data const d2(10,20,100); //定义常对象

• 常对象中的数据成员均是const的， 因此必须要有初值。
  无论什么情况下， 常对象中的数据成员都不能被修改。
• 除了合成的默认构造函数和默认析构函数外， 也不能调用常对象的非const型的成员函数。
  例如：

d1.data=10; //错误， 常对象数据成员data为const， 不能成为左值
d2.show(); //错误， 不能调用常对象中非const型成员函数

• 在实际编程中， 有时一定要修改常对象中的某个数据成员的值， 这时可以将数据成员声明为mutable（可变的） 来修改它的值。
  声明形式为：

mutable 数据成员类型 数据成员名列表; //可变的数据成员声明
其中mutable为C++关键字， 表示可变的数据成员。
eg：
mutable int data; //可变的数据成员

2.常数据成员

• 在声明数据成员时使用const限定， 称它为常数据成员。
  声明的一般形式为：

const 数据成员类型 数据成员名列表; //常数据成员声明

eg：
const int data;//常数据成员声明

• 无论是成员函数还是非成员函数都不允许修改常数据成员的值。
• 常数据成员只能通过构造函数初始化列表进行初始化。

3.常成员函数

• 在定义成员函数时使用const限定， 称它为常成员函数。
  定义的一般形式为：

class 类名 
{ //类体
	…
	返回类型 函数名(形式参数列表) const //常成员函数定义
	{
		函数体
	}
	…
};

或者
class 类名 
{ //类体
	…
	返回类型 函数名(类型1 参数名1,类型2 参数名2,…) const;
	…
};
返回类型 类名::函数名(形式参数列表) const //常成员函数外部定义
{
	函数体
}

eg：//const要写在声明和定义处
int getx() const; //类体声明常成员函数
int Data::getx() const //外部定义常成员函数
{
	return x;
}

需要注意const的位置在函数头和函数体之间， 不要写成：
const 返回类型 函数名(类型1 参数名1,类型2 参数名2,…);//这种写法表示函数返回值只读（如返回只读引用） 。

• 无论声明还是定义常成员函数都要有const关键字。
  常成员函数可以访问const数据成员， 也可以访问非const的数据成员。
  const数据成员可以被const成员函数访问， 也可以被非const的成员函数访问。
  具体情况见下<const限定访问关系>表：

数据成员 						非常成员函数（普通数据成员） 				常成员函数
非常数据成员(普通数据成员) 										允许访问，可以修改 允许访问，不能修改
常数据成员 							允许访问，不能修改 					允许访问，不能修改
常对象数据成员 						不允许访问和修改 					允许访问，不能修改

• 关于常成员函数的说明
  （1）在一个类中， 如果有些数据成员的值允许修改， 另一些数据成员的值不允许修改， 那么可以将一部分数据成员声明为const（常数据成员） ， 使得其值不能被修改。 而普通的成员函数可以修改普通的数据成员， 但只能访问常数据成员的值。
  （2）如果要求所有数据成员的值都不允许改变， 可以将对象声明为const的（常对象） ， 那么只能用const成员函数访问数据成员，且不能修改其值。 这样， 数据成员无论如何也不会被修改。
  （3）如果定义了一个常对象， 只能调用其中的const成员函数， 而不能调用非const成员函数。 如果需要访问对象中的数据成员， 可将常对象中所有成员函数都声明为const成员函数， 但应确保在函数中不会修改对象中的数据成员。
  （4）常对象中的成员函数不一定是常成员函数。 如果在常对象中的成员函数未加const声明， C++把它作为非常成员函数处理。
  （5）常成员函数不能调用另一个非常成员函数。

4.指向对象的常指针

• 指向对象的常指针定义形式如下：
• 通常， 使用常指针作为函数的形参， 目的是不允许在函数执行过程中改变指针变量的值， 使其始终指向原来的对象。 如果在函数执行过程中试图修改常指针形参的值， 就会出现编译错误。

类名 * const 指针变量名=对象地址; //常指针

• 其含义是这样的指针始终保持其初值， 程序中不能修改其指向。
  eg：

Data d(10,20,100), d1;
Data *const p=&d; //定义指向对象的常指针
p=&d1; //错误， 不能修改常指针的指针值

请注意， 对象的常指针必须在定义时初始化， 因为其后就不能再指向别的对象了。
虽然常指针是const的不能改变指向， 但常指针所指向的对象却不一定是const的。

5.指向常对象的指针变量

• 指向常对象的指针变量定义形式如下：

const 类名 * 指针变量名;

• 其含义是指针变量指向的对象为const（即常对象） 。
  eg:

const Data *p; //指向常对象的指针变量

指针p的指向却是可以改变的

• 指向常对象的指针变量， 是不能通过它改变所指向的对象的值， 但是指针变量本身的值是可以改变的， 因此可以在定义时不初始化。

• 请注意指向对象的常指针变量与指向常对象的指针变量的区别：

Data *const p=&d; //定义指向对象的常指针  指针的指向是不能改变的
const Data *p; //指向常对象的指针变量    不能通过指针指向其它对象的值的

（1）如果一个对象已被声明为常对象， 只能用指向常对象的指针变量指向它。

（2）如果定义了一个指向常对象的指针变量， 即使它指向一个非const的对象， 其指向的对象也是不能通过指针来改变的。
（指向常对象的指针变量可以指向常对象，也可以指向一个非常对象，但是都不能通过该指针去改变其指向对象的值）

（3）指向常对象的指针常用作函数形参， 目的是在保护形参指针所指向的对象， 使它在函数执行过程中不被修改。

6.对象的常引用

• 在C++程序中， 经常用对象的常指针和常引用作函数参数。 这样既能保证数据安全， 使数据在函数中不能被随意修改， 又在调用函数时又不必传递实参对象的副本， 大幅减少函数调用的空间和时间的开销。
• 对象常引用定义形式如下：

const 类名 & 引用变量名;

• 例如， 复制构造函数就使用了常引用作为函数唯一形参：

Data(const Data& r) : x(r.x),y(r.y),data(r.data) { } //复制构造

//只能作为传递过来对象的引用，别名

• eg：

#include <iostream>
#include <string.h>
using namespace std;
class A
{
	public:
		int getArea() const  //常成员函数不能改变数据成员的值
		{
			return w*h;
		}
		void setWH(int x, int y) // 因为该成员函数修改了数据成员的值，所以不能被定义为常成员函数
		{
			w=x;
			h=y;
		}
		A(int x,int y)
		{
			w=x;
			h=y;
		}
		A(){}
	private:
		int w,h;
};

int main()
{
	A a;//普通对象可以不初始化
	a.setWH(3,9);//a可以调用非常成员函数
	A const b;//错误， 常对象必须声明的同时初始化， 正确的是：A const b(3,6);
	
	b.setWH(3,7);//错误， 常对象不能调用非常成员函数    常对象只能调用常成员函数
	cout<<a.getArea()<<endl<<b.getArea()<<endl;

	return 0;
}