const用法详解

• const在函数前与函数后的区别

• 一   const基础   
      
    如果const关键字不涉及到指针，我们很好理解，下面是涉及到指针的情况：   
      
    int   b   =   500;   
    const   int*   a   =   &b;              [1]   
    int   const   *a   =   &b;              [2]   
    int*   const   a   =   &b;              [3]   
    const   int*   const   a   =   &b;   [4]   
      
    如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《effective   c++》item21上的做法， 如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的 右侧，const就是修饰指针本身，即指针本身是常量 。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量，这种情况下不允许对内容进行更改操 作，如不能*a   =   3   ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常 量。   
    另外const   的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const   可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：a&   operator=(const   a&   a);   
    void   fun0(const   a*   a   );   
    void   fun1(   )   const;   //   fun1(   )   为类成员函数   
    const   a   fun2(   );   
      
    二   const的初始化   
      
    先看一下const变量初始化的情况   
    1)   非指针const常量初始化的情况：a   b;   
    const   a   a   =   b;   
      
    2)   指针(引用)const常量初始化的情况：a*   d   =   new   a();   
      const   a*   c   =   d;   
    或者：const   a*   c   =   new   a();   
    引用：   
      a   f;   
      const   a&   e   =   f;   //   这样作e只能访问声明为const的函数，而不能访问一般的成员函数；   
      
    [思考1]：   以下的这种赋值方法正确吗？   
   

   const   a*   c=new   a();   
    a*   e   =   c;   //错误，不能通过e来改变c指向的const常量

  
    [思考2]：   以下的这种赋值方法正确吗？   
   

   a*   const   c   =   new   a();   
   a*   b   =   c;   //正确，c指向的变量可以被改变，c与变量的对应关系不能被改变

    
    三   作为参数和返回值的const修饰符   
      
    其实，不论是参数还是返回值，道理都是一样的，参数传入时候和函数返回的时候，初始化const变量   
    1   修饰参数的const，如   void   fun0(const   a*   a   );   void   fun1(const   a&   a);   
    调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const   a*   a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const   a&   a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。   
    [注意]：参数const通常用于参数为指针或引用的情况;   
    2   修饰返回值的const，如const   a   fun2(   );   const   a*   fun3(   );   
    这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。
• const   rational   operator*(const   rational&   lhs,   const   rational&   rhs)   
    {   
    return   rational(lhs.numerator()   *   rhs.numerator(),  lhs.denominator()   *   rhs.denominator());   
    }   
      
    返回值用const修饰可以防止允许这样的操作发生:rational   a,b;   
    radional   c;   
    (a*b)   =   c;     
    [总结]   一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对 某个对象引用的情况。   
    原因如下：   
    如果返回值为某个对象为const或某个对象的引用为const   ，则返回值具有const属性，则返回实例只能访问类a中的公有数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用 到。    
      
    [思考3]：   这样定义赋值操作符重载函数可以吗？   
    const   a&   operator=(const   a&   a);   //不可以
      
    四   类成员函数中const的使用   
      
    一般放在函数体后，形如：void   fun()   const;   
    如果一个成员函数的不会修改数据成员，那么最好将其声明为const，因为const成员函数中不允许对数据成员进行修改，如果修改，编译器将报错，这大 大提高了程序的健壮性。并且声明为const的函数可以为类实例化后的const对象和非const对象共同调用。
    五   使用const的一些建议   
      
    1   要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；   
    2   要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；   
    3   在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；   
    4   const在成员函数中的三种用法要很好的使用；   
    5   不要轻易的将函数的返回值类型定为const;   
    6   除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;  
• 
  

• 看到const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。

  const 是constant 的缩写，“恒定不变”的意思。被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。

  
  

  1.用const 修饰函数的参数

  如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const 修饰，否则该参数将失去输出功能。const 只能修饰输入参数：

  如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用。

  例如StringCopy 函数：

  void StringCopy(char *strDestination, const char *strSource);

  其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。

  如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。

  例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。

  对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。

  为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：

  “引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。

  以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。

  问题是如此的缠绵，我只好将“const &”修饰输入参数的用法总结一下。

   

  对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。

   

  对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。

  
  

  2 .用const 修饰函数的返回值
  如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。例如函数
  const char * GetString(void);
  如下语句将出现编译错误：
  char *str = GetString();
  正确的用法是
  const char *str = GetString();
  如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。
  例如不要把函数int GetInt(void) 写成const int GetInt(void)。
  同理不要把函数A GetA(void) 写成const A GetA(void)，其中A 为用户自定义的数据类型。
  如果返回值不是内部数据类型，将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。
  函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。

  例如：
  class A
  {
  A & operate = (const A &other); // 赋值函数
  };
  A a, b, c; // a, b, c 为A 的对象
  
  a = b = c; // 正常的链式赋值
  (a = b) = c; // 不正常的链式赋值，但合法
  如果将赋值函数的返回值加const 修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c 仍然正确，但是语句 (a = b) = c 则是非法的。

  
  

  3. const 成员函数
  任何不会修改数据成员(即函数中的变量)的函数都应该声明为const 类型。如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。
  class Stack
  {
  public:
  void Push(int elem);
  int Pop(void);
  int GetCount(void) const; // const 成员函数
  private:
  int m_num;
  int m_data[100];
  };
  int Stack::GetCount(void) const
  {
  ++ m_num; // 编译错误，企图修改数据成员m_num
  Pop(); // 编译错误，企图调用非const 函数
  return m_num;
  }
  const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。
  关于Const函数的几点规则：
  
  a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
  b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
  c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
  e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的