Note4、const

const限定符把一个对象转换成一个常量。

const最常见用途如下：

常变量	const 类型说明符 变量名
常引用	const 类型说明符 &引用名
常对象	类名 const 对象名
常成员函数	类名::fun(形参)  const
常数组	类型说明符 const 数组名[大小]
常指针	const 类型说明符* 指针名；类型说明符* const 指针名；const类型说明符* const 指针名

注：在常变量、常引用、常对象、常数组中，“const”与“类型说明符”或“类名”（其实类名是一种自定义的类型说明符）的位置可以互换。如：

const int a=5; 与 int const a=5; 等同

类名 const 对象名与 const 类名对象名 等同

1、定义常量

（1）const修饰变量，以下两种定义形式在本质上是一样的。它的含义是：const修饰的类型为TYPE的变量value是不可变的。

TYPE const ValueName = value;  

const TYPE ValueName = value;

（2）将const改为外部连接，作用域扩大至全局，编译时会分配内存，并且可以不进行初始化，仅仅作为声明，编译器认为在程序其他地方进行了定义。

extend const int ValueName = value;

（#BK001#_P50）

在全局作用域里定义非const 变量时，它在整个程序中都可以访问。我们可以把一个非 const变量定义在一个文件中，假设已经做了合适的声明，就可在另外的文件中使用这个变量：

// file_1.cc

int counter; // definition

// file_2.cc

extern int counter; // uses counter from file_1

++counter; // increments counter defined in file_1

与其他变量不同，除非特别说明，在全局作用域声明的const变量是定义该对象的文件的局部变量。此变量只存在于那个文件中，不能被其他文件访问。

通过指定const变量为 extern，就可以在整个程序中访问const对象：

// file_1.cc

// defines and initializes a const that is accessible to other files

extern const int bufSize = fcn();

// file_2.cc

extern const int bufSize; // uses bufSize from file_1

// uses bufSize defined in file_1

for (int index = 0; index != bufSize; ++index)

// ...

本程序中，file_1.cc通过函数fcn的返回值来定义和初始化bufSize。而 bufSize 定义为 extern，也就意味着bufSize可以在其他的文件中使用。file_2.cc中bufSize的声明同样是 extern；这种情况下，extern标志着bufSize 是一个声明，所以没有初始化式。

非const变量默认为extern。要使const变量能够在其他的文件中访问，必须显式地指定它为extern。

2、指针使用const

（1）指针本身是常量不可变

  char* const pContent;

（2）指针所指向的内容是常量不可变

  const char *pContent;

（3）两者都不可变

  const char* const pContent;

（4）区别方法，沿着*号划一条线：

如果const位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；

如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。

（5）指针和 typedef

在typedef中使用指针往往会带来意外的结果。下面是一个几乎所有人刚开始时都会答错的问题。假设给出以下语句：

typedef string *pstring;

const pstring cstr;

请问 cstr 变量是什么类型？简单的回答是 const pstring 类型的指针。进一步问：const pstring指针所表示的真实类型是什么？很多人都认为真正的类型是：

const string *cstr; // wrong interpretation of const pstring cstr

也就是说，constpstring是一种指针，指向string类型的const对象，但这是错误的。错误的原因在于将typedef当做文本扩展了。声明const pstring时，const修饰的是pstring 的类型，这是一个指针。因此，该声明语句应该是把cstr定义为指向string类型对象的const 指针，这个定义等价于：

// cstr is a const pointer to string

string *const cstr; // equivalent to const pstring cstr

（6）允许把非const对象的地址赋给指向const对象的指针，不允许把一个const对象的地址赋给一个普通的、非const对象的指针。

3、函数中使用const

(1)const修饰函数参数

a.传递过来的参数在函数内不可以改变(无意义，因为Var本身就是形参)

void function(const int Var);

b.参数指针所指内容为常量不可变

void function(const char* Var);

c.参数指针本身为常量不可变(也无意义，因为char* Var也是形参)

void function(char* const Var);

d.参数为引用，为了增加效率同时防止修改。修饰引用参数时：

void function(const Class& Var); //引用参数在函数内不可以改变

void function(const TYPE& Var); //引用参数在函数内为常量不可变

这样的一个const引用传递和最普通的函数按值传递的效果是一模一样的，他禁止对引用的对象的一切修改，唯一不同的是按值传递会先建立一个类对象的副本，然后传递过去，而它直接传递地址，所以这种传递比按值传递更有效。另外只有引用的const传递可以传递一个临时对象，因为临时对象都是const属性，且是不可见的，它短时间存在一个局部域中，所以不能使用指针，只有引用的const传递能够捕捉到这个家伙。

(2)const修饰函数返回值

const修饰函数返回值其实用的并不是很多，它的含义和const修饰普通变量以及指针的含义基本相同。

a.const intfun1() //这个其实无意义，因为参数返回本身就是赋值。

b.const int * fun2() //调用时 const int *pValue= fun2();

                //我们可以把fun2()看作成一个变量，即指针内容不可变。

c.int* const fun3() //调用时 int * const pValue = fun3();

               //我们可以把fun3()看作成一个变量，即指针本身不可变。

一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例），则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。

4、类相关const

（1）const修饰成员变量

const修饰类的成员变量，表示成员变量不能被修改，同时它只能在初始化列表中赋值。

    class A

    {

        …

         const int nValue;       //成员常量不能被修改

        …

        A(int x): nValue(x) {} ;     //只能在初始化列表中赋值

     }

const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如

class A

{       

…

enum {size1=100, size2 = 200 };

int array1[size1];

int array2[size2];

}

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

(2)const修饰成员函数

const修饰类的成员函数，则该成员函数不能修改类中任何非const成员函数。一般写在函数的最后来修饰。

    class A

     {

         …

       void function() const;        //常成员函数, 它不改变对象的成员变量，

//也不能调用类中任何非const成员函数。

}

对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使用。

a. const成员函数不被允许修改它所在对象的任何一个数据成员。

b. const成员函数能够访问对象的const成员，而其他成员函数不可以。

(3)const修饰类对象/对象指针/对象引用

const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。对于对象指针和对象引用也是一样。

const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

例如：

class AAA

{

    void func1();

void func2() const;

}

const AAA aObj;

aObj.func1(); ×

aObj.func2(); 正确

const AAA* aObj = new AAA();

aObj-> func1(); ×

aObj-> func2(); 正确

序号	书籍
#BK001#	C++ primer中文版（第4版）
#BK002#	程序员面试宝典（第三版）
#BK003#	编写高质量代码改善C++程序的150个建议