关于const关键字

1.const 与 #define的比较

（1）const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。

（2) 有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。(这点到没有遇到过)在C++ 程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

2.类中的常量

有时我们希望某些常量只在类中有效。由于#define定义的宏常量是全局的，不能达到目的，于是想当然地觉得应该用const修饰数据成员来实现。const数据成员的确是存在的，但其含义却不是我们所期望的。const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。不能在类声明中初始化const数据成员。以下用法是错误的，因为类的对象未被创建时，编译器不知道SIZE的值是什么。

    class A

    {…

        const int SIZE = 100;     // 错误，企图在类声明中初始化const数据成员（原因可能是初始化意味这空间分配）

        int array[SIZE];        // 错误，未知的SIZE

    };

const数据成员的初始化只能在类构造函数的初始化表中进行，但是是在某个对象中为常量，在类中并不是常量。例如

    class A

    {…

        A(int size);      // 构造函数

        const int SIZE ;

    };

    A::A(int size) : SIZE(size)    // 构造函数的初始化表

    {

      …

    }

    A  a(100); // 对象 a 的SIZE值为100

    A  b(200); // 对象 b 的SIZE值为200

 

    怎样才能建立在整个类中都恒定的常量呢？别指望const数据成员了，应该用类中的枚举常量来实现。例如

    class A

    {…

        enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量

        int array1[SIZE1]; 

        int array2[SIZE2];

    };

枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。

3.使用const提高函数的健壮性

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

const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const修饰，否则该参数将失去输出功能。

1）如果参数是指针，且仅作输入用，则应在类型前加const，以防止该指针在函数体内被意外修改。

void StringCopy(char *strDestination，const char *strSource);（是指针可以改变，可以strSource++,但是指针指向的内容不可以改变，strSource[1]++,编译器“increment of read-only location”。）

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

为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。

例如：String String(const String &other)，拷贝构造函数一般都是这种形式。

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

3）如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。因为传进去的为这个参数的拷贝，改动并不影响原来的参数。（指针比较特殊，虽然没有影响指针，但是指针的拷贝仍然和原指针指向同一块内存空间，可能改变）

例如不要将函数void Func1(int x) 写成void Func1(const int x)。

4）const成员函数，任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。const成员函数的声明看起来怪怪的：const关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。const成员函数应该在函数原型说明和函数定义中都增加const限定，因为同一个类里面可能存在两个函数，这两个函数返回值，输入参数和函数名字都一样，区别只是一个有const修饰，一个没有而已。

const成员函数和const对象：实际上，const成员函数还有另外一项作用，即常量对象相关。对于内置的数据类型，我们可以定义它们的常量，用户自定义的类也一样，可以定义它们的常量对象。例如，定义一个整型常量的方法为：
const int i=1 ；
同样，也可以定义常量对象，假定有一个类classA，定义该类的常量对象的方法为：
const classA  a(2)；
这里，a是类classA的一个const对象，"2"传给它的构造函数参数。const对象的数据成员在对象寿命期内不能改变。但是，如何保证该类的数据成员不被改变呢？为了确保const对象的数据成员不会被改变，在C++中，const对象只能调用const成员函数，如果像让一个const func修改成员变量，那么要在类中对这个数据成员加上一个关键字，mutable（容易改变的意思）就可以了。如果一个成员函数实际上没有对数据成员作任何形式的修改，但是它没有被const关键字限定的，也不能被常量对象调用。例子如下

#include <iostream>
using namespace std;

class A{
        public:
                A(){};
                void func(){printf("not const\n");}
                void func() const {printf("const \n");}
};

int main()
{
        const A a1;
        A a2;
        a1.func();
        a2.func();
}

输出为：
const
not const

如果没有定义那个void func() const只定义了void func()，那么a1.func()的时候，编译器会说“错误：将 ‘const A’ 作为 ‘void A::func()’ 的 ‘this’ 实参时丢弃了类型限定”。（一个const对象不能调用一个non-const的成员函数，目的是“为了确保const对象的数据成员不会被改变”，所以不能调用non-const的成员函数）

但是如果没有定义那个void fun(),只定义了void fun() const,那么编译成功，并且有输出：
const
const
可见，一个non-const 对象，能够调用一个const成员函数。总结如下，可见只要记住一点就OK，那就是，const的对象或成员函数，不能调用non-const成员函数，因为在non-const里面，可能会更改类的数据成员，这就违背了cosnt func的本意。

 

      对象          成员函数       对/错
1、   const         const           对
2、   const         non-const       错
3、   non-const     const           对
4、   not-const     non-const       对

     成员函数       成员函数       对/错
5、   const         const           对
6、   const         non-const       错
7、   non-const     const           对
8、   non-const     non-const       对

5）最后要说一以下const与指针的问题

const char *, char const *, char * cosnt，都什么东西。
const char *前面已经说过，这个指针指向的内容不可以改变，经常用来修饰函数的参数，但是这个指针值可以改变。
int const * 和const char *效果一样。
char * const 指针值不可以改变，但是指针指向的内容可以改变。

char a[] = "hello";
char b[] = "world";
const char *p1 = a;
char * const p2 = a;
p1[0]++;  //编译错误“increment of read-only location”
p1 = b;   //OK
p2[0]++;  //OK
p2 = b;   //编译错误“assignment of read-only variable ‘p2’”
”

6）最最后有一定，一个函数不能即是static的又是const的

否则编译器会报错：“static 成员函数 ‘static int A::fun()’ 不能拥有 cv 限定符”。

C++编译器在实现const的成员函数的时候为了确保该函数不能修改类的实例的状态，会在函数中添加一个隐式的参数const this*。但当一个成员为static的时候，该函数是没有this指针的。也就是说此时static的用法和static是冲突的。

我们也可以这样理解：两者的语意是矛盾的。static的作用是表示该函数只作用在类型的静态变量上，与类的实例没有关系；而const的作用是确保函数不能修改类的实例的状态，与类型的静态变量没有关系。因此不能同时用它们。

 

 

参考：
林锐 高质量C++编程指南
Lippman C++ primer