c++中const关键字的使用完整攻略

c++中const关键字，将一个变量声明为常量，在这个基础上进行编程，通过这个关键字可以区分两个成员函数，限制成员函数的行为，并且由于定义的不同位置，而又不尽相同的意义。

#include <iostream>
 using namespace std;
 class Base{
 public:
     Base(const int a):elem(a){
         cout<<"base const"<<endl;
     }
     void test(){}
     int mul(const int a)const
     {
         cout<<"base int mul(const int a)const    ";
         return a*elem;
     }
 private:
     int elem;
 };
 
 int main(){
     int te = 2;
     Base *p = new Base(te);
     int temp = 2;
     const int a = temp;
     temp = p->mul(a);
     cout<<temp<<endl;
     return 0;
 }

在Base的构造方法中，形参表的成员以const修饰，这就说明这个函数不会修改传入的实参。如果在调用的时候出现non-const的形参，也会调用这个方法；如果构造方法不加const修饰形参，而使用时以const实参加载，也会正常调用这个方法。

这是一个简单的应用，在一个成员函数的尾部加上const关键字，意味着定义了一个const成员函数，const成员函数不能修改任何数据成员，也不能调用任何non-const成员函数。

如果在const函数中调用non-const成员函数，或是修改成员变量，编译器会主动提示错误。

vs2008中提示的错误就是   "左值指定 const 对象"。

在本例当中如果mul方法调用test（）方法，或是修改成员变量elem的值，编译器就会主动提示错误。

程序执行结果：

base const
base int mul(const int a)const  4
请按任意键继续. . .

#include <iostream>
  using namespace std;
  class Base{
  public:
      Base(const int a):elem(a){
          cout<<"base const"<<endl;
      }
      void test(){cout<<"test";}
      int mul(const int a)const
      {
          cout<<"base int mul(const int a)const    ";
          //elem = 3;
          //test();
          return a*elem;
      }
     /*
     int mul(const int a)
      {
          cout<<"base int mul(const int a)const    ";
          elem = 3;
          test();
          return a*elem;
      }
      */
      int mul(int &a)
      {
          test();
          cout<<"base int mul(int &a)    ";
          return elem = a*elem;
      }
  private:
      int elem;
  };
  int main(){
      Base *p = new Base(2);
      int temp = 2;
      const int a = temp;
      temp = p->mul(a);
      cout<<temp<<endl;
      int &b = temp;
      temp = p->mul(b);
      cout<<temp<<endl;
      return 0;
  }

在一个类中，定义多个函数，有相同的函数名，以及不尽相同的形参表，在这种情况下，函数调用总是选择最为接近的那个。——这是函数重载的调用规则。

但是对于const关键字并不适用，const关键字对于函数调用采取的是不同的调用策略。

同时定义const形参方法和non-const形参方法

void print(int &a,int &b,int &c,int &d){
        cout<<"non-const"<<a<<"non-const"<<b<<"non-const"<<c<<"non-const"<<d<<endl;
     }
void print(const int &a,const int &b,const int &c,const int &d)const
     {
        cout<<"const"<<a<<"const"<<b<<"const"<<c<<"const"<<d<<endl;
     }

 如果我们定义4个const int引用和4个non-const int引用，然后调用这两个函数，产生的结果就完全不是以重载考虑问题所想象的 结果了。

#include <iostream>
  using namespace std;
  class Base{
  public:
      Base(const int a):elem(a){
          cout<<"base const"<<endl;
      }
      void print(int &a,int &b,int &c,int &d){
         cout<<"non-const"<<a<<"non-const"<<b<<"non-const"<<c<<"non-const"<<d<<endl;
      }
      void print(int &a,int &b,const int &c,const int &d)const
      {
         cout<<"non-const"<<a<<"non-const"<<b<<"const"<<c<<"const"<<d<<endl;
      }
      void print(const int &a,const int &b,const int &c,const int &d)const
      {
         cout<<"const"<<a<<"const"<<b<<"const"<<c<<"const"<<d<<endl;
      }
  private:
      int elem;
  };
  int main(){
      Base *p = new Base(0);
      int nconst_a=1,nconst_b=2,nconst_c=3,nconst_d=4;
      const int &const_a=1,&const_b=2,&const_c=3,&const_d=4;
      p->print(nconst_a,nconst_b,nconst_c,nconst_d);//4-0
      p->print(nconst_a,nconst_b,nconst_c,const_d);//3-1
      p->print(nconst_a,nconst_b,const_c,const_d);//2-2
      p->print(nconst_a,const_b,const_c,const_d);//1-3
      p->print(const_a,const_b,const_c,const_d);//0-4
      return 0;
  }

上述代码在主函数中调用这两个成员函数，在这里分别加载0-4个const成员变量，如果按照重载的定义规则，这上下各有两个调用相似类型较多的函数，中间的函数会出现一个不确定操作进而编译器不让我们用这种东西折磨他。。。
不过很奇怪的是，如果把这个代码提交编译，编译器都是十分乐意地完成了compile和link，然后毫不客气的给出了与我们预期完全不同的运行结果。

程序运行结果：

base const
non-const1non-const2non-const3non-const4
non-const1non-const2const3const4
non-const1non-const2const3const4
const1const2const3const4
const1const2const3const4
请按任意键继续. . .

 只要有const成员出现，就要调用调用满足const成员的最接近方法。

不过，如果没有函数能够提供针对这么多的const 实参的成员函数，这时候编译器就会突然决定：

你玩蛋去吧！！！

1>Const.cpp
1>d:\backup\我的文档\visual studio 2008\projects\test_const\test_const\const.cpp(25) : error C2664: “void Base::print(int &,int &,int &,int &)”: 不能将参数 2 从“const int”转换为“int &”
1>        转换丢失限定符
1>d:\backup\我的文档\visual studio 2008\projects\test_const\test_const\const.cpp(26) : error C2664: “void Base::print(int &,int &,int &,int &)”: 不能将参数 1 从“const int”转换为“int &”
1>        转换丢失限定符

 所以const不是重载，const成员函数如果不会改变一个实参，就尽可能将其设为const，毕竟在形参表中定义的const关键字，意味着对于这个位置的这个类型的数据，朕老少通吃。

 

c++作为一个强大的语言，意味着他不单单能够吃饭睡觉挣钱，还能找妹子生孩子，而且和Java的计划生育政策不同的是，c++只要你能够优生，是不会禁止你生多少个孩子，养多少个孙子的。。。

所以在面向对象的时候，子类对父类的操作，对父类方法的继承和重写，完全遵循c++面向对象的规定。

#include <iostream>
 using namespace std;
 class Base{
 public:
     Base(const int a):elem(a){
         cout<<"base const"<<endl;
     }
     void test(){cout<<"test    ";}
     virtual int mul(const int &a)
     {
         test();
         cout<<"base int mul(const int &a)    ";
         return elem = a*elem;
     }
     virtual int mul(int &a)
     {
         test();
         cout<<"base int mul(int &a)    ";
         return elem = a*elem;
     }
 private:
     int elem;
 };
 class Derived:public Base{
 public:
     Derived(const int a):Base(a){
         cout<<"derived const"<<endl;
     }
     int mul(const int &a)
     {
         test();
         cout<<"derived int mul(const int &a)    ";
         return a;
     }
     int mul(int &a)
     {
         test();
         cout<<"derived int mul(int &a)    ";
         return a;
     }
 };
 int main(){
     Base *p = new Base(2);
     Base *q = new Derived(3);
     int temp = 2;
     const int a = temp;
     temp = p->mul(a);
     cout<<temp<<endl;
     temp = p->mul(temp);
     cout<<temp<<endl;    
     cout<<q->mul(temp)<<endl;    
     cout<<q->mul(a)<<endl;  
     return EXIT_SUCCESS;
 }

程序的执行结果毫不出乎我们的意料之外，完全按照继承派生——找妹子生孩子这个套路进行函数调用，父类对象调用父类方法，子类对象使用父类指针范围，但是照样使用子类的方法。
程序运行结果：

base const
base const
derived const
test    base int mul(const int &a)    4
test    base int mul(int &a)    16
test    derived int mul(int &a)    16
test    derived int mul(const int &a)    2
请按任意键继续. . .

 如果基类的成员函数被继承类重写了一个父类方法，然后没有重写另一个方法，这时候调用就会显得十分有趣而符合逻辑。

c++继承的过程相当于子类隐式增加了父类的方法，如果子类不重写这个方法，这个方法就是实际存在的而且与子类的其他方法完全相同。

父类有const版本和non-const版本的成员函数，如果子类重新non-const版本，则在调用const版本的时候就必须调用父类的const版本的成员函数——因为如果调用成员函数时候传入const对象，意味着程序员知道这个对象是有const版本的成员函数的，无论他在子类还是父类。

#include <iostream>
 using namespace std;
 class Base{
 public:
     Base(const int a):elem(a){
         cout<<"base const"<<endl;
     }
     void test(){cout<<"test    ";}
     virtual int mul(const int &a)
     {
         test();
         cout<<"base int mul(const int &a)    ";
         return elem = a*elem;
     }
     virtual int mul(int &a)
     {
         test();
         cout<<"base int mul(int &a)    ";
         return elem = a*elem;
     }
 private:
     int elem;
 };
 class Derived:public Base{
 public:
     Derived(const int a):Base(a){
         cout<<"derived const"<<endl;
     }
     int mul(int &a)
     {
         test();
         cout<<"derived int mul(int &a)    ";
         return a;
     }
 };
 int main(){
     Base *p = new Base(2);
     Base *q = new Derived(3);
     int temp = 2;
     const int a = temp;
     temp = p->mul(a);
     cout<<temp<<endl;
     temp = p->mul(temp);
     cout<<temp<<endl;    
     cout<<q->mul(temp)<<endl;    
     cout<<q->mul(a)<<endl;  
     return EXIT_SUCCESS;
 }

程序运行结果：

base const
base const
derived const
test    base int mul(const int &a)    4
test    base int mul(int &a)    16
test    derived int mul(int &a)    16
test    base int mul(const int &a)    6
请按任意键继续. . .

问题出现在子类重写const版本的成员函数的时候，如果子类不知道父类有哪些方法，自己写了一个const版本的方法，然后就期待着这个方法老少通吃，这时候在子类调用non-const版本的方法的时候，理所当然的会调用隐式存在的non-const版本的方法，这时候对于构建子类的程序员就出现了一个无法理解的现象，只定义了一个const版本的成员函数，由于父类中存在non-const版本的函数，所以无法访问自己希望访问的方法。如果重新一个子类的non-const版本完全相同的成员函数，我们就相当于做了一个复制粘贴的工作，增加了代码的维护代价。

在这里就给出一个建议：如果一个类有可能被继承，则这个父类如果并无必要使用一个non-const版本的成员函数，就尽量不定义这个函数，或是定义一个const版本的，子类需要自定义的const版本的时候，就可以重写；如果子类需要自定义non-const版本的时候，就可以重载。

#include <iostream>
 using namespace std;
 class Base{
 public:
     Base(const int a):elem(a){
         cout<<"base const"<<endl;
     }
     void test(){cout<<"test    ";}
     virtual int mul(const int &a)
     {
         test();
         cout<<"base int mul(const int &a)    ";
         return elem = a*elem;
     }
     virtual int mul(int &a)
     {
         test();
         cout<<"base int mul(int &a)    ";
         return elem = a*elem;
     }
 private:
     int elem;
 };
 class Derived:public Base{
 public:
     Derived(const int a):Base(a){
         cout<<"derived const"<<endl;
     }
     int mul(const int &a)
     {
         test();
         cout<<"derived int mul(const int &a)    ";
         return a;
     }
 };
 int main(){
     Base *p = new Base(2);
     Base *q = new Derived(3);
     int temp = 2;
     const int a = temp;
     temp = p->mul(a);
     cout<<temp<<endl;
     temp = p->mul(temp);
     cout<<temp<<endl;    
     cout<<q->mul(temp)<<endl;    
     cout<<q->mul(a)<<endl;  
     return EXIT_SUCCESS;
 }

程序运行结果：

base const
base const
derived const
test    base int mul(const int &a)    4
test    base int mul(int &a)    16
test    base int mul(int &a)    48
test    derived int mul(const int &a)    2
请按任意键继续. . .

而const 对象调用不同版本的成员函数时候，是通过成员函数的修饰符来决定调用方式的。

#include <iostream>
using namespace std;
class Base{
public:
    Base():size(0),info(NULL){}
    Base(int s,int* p):size(s),info(p){}
    Base(const Base &obj){
        size = obj.size;
        info = obj.info;
    }
    Base& operator = (const Base &obj){
        size = obj.size;
        info = obj.info;
        return *this;
    }
    bool operator == (const Base &obj){
        cout<<"bool operator == (const Base &obj)"<<endl;
        if(size != obj.size)
            return false;
        if(*info != *obj.info)
            return false;
        return true;
    }
    bool operator == (const Base &obj) const {
        cout<<"bool operator == (const Base &obj) const "<<endl;
        if(size != obj.size)
            return false;
        if(*info != *obj.info)
            return false;
        return true;
    }
    void print() const;
private:
    int size;
    int* info;
};
void Base::print() const {
    int index = 0;
    for(;index<size;index++){
        cout<<*(info+index)<<"    ";
    }
    cout<<endl;
}

int main(){
    int *p = new int(3);
    Base a(1,p);
    const Base c(a);
    const Base b(2,p);
    cout<<(a==b)<<endl;
    cout<<(c==b)<<endl;
    return EXIT_SUCCESS;
}

主函数中调用==的两个重载版本，而const和non-const对象调用的是不同的版本。

bool operator == (const Base &obj)
0
bool operator == (const Base &obj) const
0
请按任意键继续. . .