关于const用法的学习

　　被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。
1、const作函数参数
　　例如函数 

void addTeacher(Teacher t);

　　如果是值传递，这样会使程序的效率降低，因为值传递过程中函数入口的参数是临时变量，用于复制主函数中函数调用传来的值，这个过程中临时变量的构造、复制、析构等过程都需要消耗时间，所以这个时候就考虑引用传递，如下：

void addTeacher(Teacher &t);

　　因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象，所以提升了程序的效率。但是函数参数引用存在一个缺点，在函数“引用传递”时可能改变参数t的内容，正因如此，所以这个时候就可以通过添加const关键字去完善，如下：

void addTeacher(const Teacher &t);

注意：对于某些内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如voidFunc(int x) 不应该改为voidFunc(const int &x)。
2、const作函数的返回值
  　　 如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。例如函数

const char * GetString();

 　　如下语句将出现编译错误：

char *str = GetString();

 　　正确的用法是

const char *str =GetString();

　　如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。例如不要把函数intGetInt(void) 写成constint GetInt(void)。如果返回值不是内部数据类型，将函数AGetA(void) 改写为constA &GetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。例如： 

class A
{
public:
    A(char c){
        this->x=c;
    }
     A & operator =(const A a){
        cout<<"Test "<<x<<"="<<a.x<<endl;
    }
private:
    char x;
};
int main(){
    A a('a'), b('b'), c('c'); // a, b, c 为A的对象
    a = b = c; // 正常的链式赋值
    ( a = b ) = c ;// 不正常的链式赋值，但合法
}

 如果将赋值函数的返回值加const修饰

const A & operator =(const A a){
        cout<<"Test "<<x<<"="<<a.x<<endl;
    }

 那么该返回值的内容不允许被改动。上例中，语句a= b = c 仍然正确，但是语句(a= b) = c 则是非法的。（a=b=c中，的执行顺序是b=c,a=b;而(a=b)=c的执行顺序是a=b,a=c,即试图修改a的值)。

3、成员函数

　　const成员函数的声明看起来怪怪的：const关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。
　　任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。如下程序将会报错，

class A
{
public:
    A(char c){
        this->x=c;
    }
     A & operator =(const A a){
        cout<<"Test "<<x<<"="<<a.x<<endl;
    }
    void print() const{
        cout<<"x(value): "<<x<<endl;
        x='y';
    }
private:
    char x;
};

4、mutable

　　如果现在，我们要在上述代码中增添一个功能：计算每个对象的输出次数。如果用来计数的变量是普通的变量的话，那么在const成员函数print()里面是不能修改该变量的值的；所以应该为了修改该变量而去掉其附加的const属性。这个时候，就该我们的mutable出场了——只要用mutalbe来修饰这个变量，所有问题就迎刃而解了。代码如下：

class A
{
public:
    A(char c){
        this->x=c;
        count=0;
    }
    const A & operator =(const A a){
        cout<<"Test "<<x<<"="<<a.x<<endl;
    }
     void print() const {
         count++;
        cout<<"x(value): "<<x<<"  count:"<<count<<endl;
    }
private:
    char x;
    mutable int count;
};
int main(){
    A a('a');
    a.print();
    a.print();
}

 关于Const函数的几点规则：
　　a.const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
　　b.const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
　　c.const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
　　d.然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的

本文部分转载自：https://blog.csdn.net/zcf1002797280/article/details/7816977