C++ ---- 公用数据的保护

Achievements provide the only real pleasure in life.

C++虽然采用了不少有效的措施（如设private保护）以增强数据的安全性，但是不同场合往往会不同的途经访问同一个数据对象。既要数据能在一定范围内共享，又要保证它不被任意修改，这时可以使用const，即有关的数据定义为常量。

<1> 常对象

定义对象时指定的对象为常对象。常对象中的数据成员为常变量且必须要有初始值。如：

Time const t1(12，34，46);          //t1是常对象

所有场合下，t1中所有的数据成员的值都不能被改变。一般格式为：

类名 const 对象名[(实参列表)];        

const 类名 对象名[(实参列表)];

二者等价。一旦被声明为常对象，则不能调用该对象的非const型的成员函数（除了由系统自动调用的隐式的构造函数和析构函数）。那如何引用常对象中的数据成员呢？只需要将成员函数声明为cont即可。如：

void get_time() const;            //将函数声明为const

表示get_time()是一个const函数，即常成员函数。常成员函数可以访问常对象中的数据成员，但不允许修改常对象中的数据成员的值。

 

<2> 常对象成员

声明类时，将成员声明为const，即声明常数据成员和常成员函数。

常数据成员，用关键字const声明常数据成员。其值是不能被改变的。只能通过构造函数的参数初始化表对常数据成员进行初始化。

类中声明常数据成员hour:

const int hour;         //声明hour为常数据成员

不能采用如下赋值方法，

Time::Time(int h)
{
   hour = h;          //非法
}

因为数据成员是不能被赋值的。

应该写成

Time::Time(int h) : hour(h){}   //通过参数初始化表对数据成员hour初始化。

类中声明一个数据成员为常数数据成员后，该类的所有对象中的该数据成员的值都是不能被改变的。但不同对象中数据成员的值可以是不同的。

如果将成员函数声明为常成员函数，则只能引用本类中的数据成员，而不能修改它们。例如只能用于输出。如：

void get_time() const;         //注意const的位置在函数名和括号之后。

const是函数类型的一部分，在声明函数和定义函数时都要有const关键字，在调用时不必加const。

常成员函数有什么意义呢？

（1）如果一个类中，有些数据成员的值可以被改变，有些数据成员不允许被改变。则可以将一部分数据成员声明为const，保证值不会被改变。

（2）如果要求所有数据成员的值都不允许被改变，则可以将所有的数据成员声明为const，或者将对象声明为const（常对象），然后用const成员函数引用数据成员，可以起到“双保险”作用。

（3）如果已经指定了一个常对象，只能调用其中的const成员函数，而不能调用非const成员函数。这是为了保证数据的安全。

记住：常成员函数不能调用非const成员函数。

<3>指向对象的常指针

指针变量声明为const型并将之初始化，这样指针值始终保持为其初值，不能改变，即指向始终不变。

一般格式：

类名 * const 指针变量名 = 对象地址；

常指针指向对象的值不能被改变，但可以改变其所指向对象的数据成员的值。往往用常指针指向函数的形参，目的是不允许函数执行过程中改变指针变量的值，使其始终指向原来的对象。如果在函数执行的过程中改变了该形参的值，编译系统就会发生编译错误，这样比人工保证形参的值不被修改更可靠。

<4>常对象的指针变量

指向常变量的指针变量：

const 类型名 * 指针变量名；

说明：1. 如果一个变量声明为常变量，那么只能用常变量的指针变量去指向它，而不能用一般的变量指向。

2. 常变量指针，除了可以指向常变量，还可以指向未被声明为的const变量。这时可以通过指针变量访问该变量，但不能改变该变量的值。但原变量的值可以被改变。

3. 如果函数形参指向是非const函数，那么函数实参只能指向非const变量的指针，而不能指向const变量的指针。如果函数的形参是指向const型变量的指针，在执行过程中不允许改变指针变量的值，因此实参可以指向const变量的值，也可以指向非const变量的值。

综上所述，指向常变量的指针可以指向const和非const型的变量，而指向非const型变量的指针变量只能指向非const变量。

同理，

1. 一个常对象，只能用常对象的指针变量去指向它。而不能用一般的（非const）指针变量去指向它。

2. 常指针变量可以指向非const指针变量，但不能通过常指针改变其值。

Time t1(10,12,15);    //定义Time类对象t1，它是非const对象
const Time *p = &t1； //定义p是指向常对象的指针变量，并指向t1
t1.hour = 8；         //合法，t1不是常变量
（*p）.hour = 18；    //不合法，不能通过常指针改变t1的值

3. 指向常对象的指针最常用于函数的形参，目的在于保护形参指针所指向的对象，使它在函数执行过程中不被改变。

.
.
.
int main（）
{
   void fun(const Time *p);      //形参是指向常对象的指针变量
   Time t1(10,13,56);            //定义Time类对象是t1，它不是常对象
   fun(&t1);                     //实参是对象t1的地址
   return 0;
}

void fun(const Time *p)
{
   p -> hour = 18;               //错误
   cout << p -> hour << endl;
}

请记住如下规则：如果不希望调用函数对象的值不被修改，就应该把形参定义为常指针变量，同时用对象的地址作为实参（对象可以是const或者非const）。

4.常指针是不能改变所指向的对象的值，但是指针变量本身的值是可以被改变的。如：

const Time *p = &t1；       //定义常指针变量p，并指向t1
p = &t2;                   //p改为指向t2，合法

注意：用对象作函数参数时，在函数调用时将建立一个新的对象t，它是实参对象t1的copy。实参把值传递给形参，二者分别占用不同的存储空间。无论形参是否修改都不会影响实参的值。这种虚实结合，当对象的规模比较大时，则时间开销和空间开销都可能很大。因此常用指针作函数参数。

5.对象的常引用

变量的引用就是变量别名。实质上，变量名和引用名都是指向同一段内存单元。如果形参是变量名的引用，实参是变量名，则在调用函数进行虚实结合时，并不是为形参另外开辟一个存储空间（常称为建立实参的一个copy），而是把实参变量的地址传递给形参（引用名），这样引用也指向实参变量。

#include <iostream>
using namespace std;
class Time
{
public:
    Time(int,int,int);
    int hour;
    int minute;
    int sec;
    
};

Time :: Time(int h, int m, int s)       //constructor
{
    hour = h;
    minute = m;
    sec = s;
}

void fun(Time &t)
{
    t.hour = 18;
}


int main()
{
    Time t1(10, 13, 56);
    fun(t1);
    cout << t1.hour << endl;
    return 0;
}

输出值：18

如果不希望函数中改变实参t1的值，可以把引用t声明为const（常引用），函数原型为void fun（const Time &t1）。

总结：在C++面向对象中，常用常指针和常引用，既保证数据安全，不被随意修改，同时又不必建立实参的copy，节约时间和内存，提高程序的运行效率。

汇总如下：

形式	含义
Time const t1/const Time t1	t1是常对象，其值在任何情况下都不能被改变。
void Time::fun() const	fun是Time类的常成员函数，可以引用，但是不能修改本类中的数据成员
Time * const p;	p是指向Time对象的常指针，p的值（指向）不能改变
const Time *p;	p是指向Time类的常指针，指向类的值不能通过p改变
Time &t1 = t;	t1是Time类对象t的引用，t和t1都指向同一段内存。