旅途

c++中const的完全解析

http://blog.csdn.net/jsjwql/archive/2007/09/10/1779516.aspx

1.   const 类型定义：指明变量或对象的值是不能被更新 , 引入目的是为了取代预编译指令

2.   可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。

3.   编译器通常不为普通 const 常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

4.    可以节省空间，避免不必要的内存分配。

  例如：

     #define PI 3.14159         file:// 常量宏

     const doulbe  Pi=3.14159;  file:// 此时并未将 Pi 放入 ROM 中

        ......

     double i=Pi;             file:// 此时为 Pi 分配内存，以后不再分配！

     double I=PI;               file:// 编译期间进行宏替换，分配内存

     double j=Pi;               file:// 没有内存分配

     double J=PI;               file:// 再进行宏替换，又一次分配内存！

 const 定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象 #define 一样给出的是立即数，所以， const 定义的常量在程序运行过程中只有一份拷贝，而 #define 定义的常量在内存中有若干个拷贝。

对于基本声明

1.  const int r=100; // 标准 const 变量声明加初始化，因为默认内部连接所以必须被初始化，其作用域为此文件，编译器经过类型检查后直接用 100 在编译时替换

2.  extend const int r=100; // 将 const 改为外部连接，作用于扩大至全局，编译时会分配内存，并且可以不进行初始化，仅仅作为声明，编译器认为在程序其他地方进行了定义

但是如果外部想链接 r ，不能这样用

extern const int r=10;  // 错误！常量不可以被再次赋值

3. const int r[ ]={1,2,3,4};

struct S {int a,b;};

const S s[ ]={(1,2),(3.4)}; // 以上两种都是常量集合，编译器会为其分配内存，所以不能在编译期间使用其中的值，例如： int temp[r[2]]; 这样的编译器会报告不能找到常量表达式

  但是

 const int Max=100;

 int Array[Max]; 

正确。

 还有

  定义数组必须用常量，可以用 const 或者 #define 定义。 Static 虽然是编译时确定，也不能用来声明数组。

对于指针和引用

1.   const int *r=&x; // 声明 r 为一个指向常量的 x 的指针， r 指向的对象不能被修改，但他可以指向任何地址的常量

pointer const 可以指定普通变量 , 用改指针不能修改它指向的对象，并不表示指向的对象是 const 不能被改变，例如：

int i = 10;

const int * p =  &i;

*p = 11; //wrong

 i = 11 ; //correct

自己的一个经验：一个具体的概念可以用范型的概念来赋值，但是一个范型的概念不能用具体的概念来赋值。

我们可以把 const 指针当成普通指针的父类，因为普通指针改写了 const 属性，而具有比 const 指针更多的功能。 这样的话只有父类指针可以指向子类，而子类指针不能指向父类。

2.   int const *r=&x; // 与用法 1 完全等价，没有任何区别

3.   int * const r=&x; // 声明 r 为一个常量指针，他指向 x ， r 这个指针的指向不能被修改，但他指向的地址的内容可以修改

4.  const int * const r=&x; // 综合 1 、 3 用法， r 是一个指向常量的常量型指针

5.   const double & v;      该引用所引用的对象不能被更新

  引用必须定义是初始话，而且初始化后这个引用不能指向其他的对象。但是这里加的 const 声明不是这个意思，它是指不能改变 v 引用对象本身，也就是只能调用该对象里面的 const 成员函数。

对于类型检查

可以把一个非 const 对象赋给一个指向 const 的指针，因为有时候我们不想从这个指针来修改其对象的值；但是不可以把一个 const 对象赋值给一个非 const 指针，因为这样可能会通过这个指针改变指向对象的值，但也存在使这种操作通过的合法化写法，使用类型强制转换可以通过指针改变 const 对象：

const int r=100;

int * ptr = const_cast<int*>(&r);  //C++ 标准， C 语言使用： int * ptr =(int*)&r;

对于字符数组

如 char * name = “china”; 这样的语句，在编译时是能够通过的，但是 ”china” 是常量字符数组，任何想修改他的操作也能通过编译但会引起运行时错误，如果我们想修改字符数组的话就要使用 char name[ ] = “china”; 这种形式。

对于函数

1. void Fuction1 ( const int r ); // 此处为参数传递 const 值，意义是变量初值不能被函数改变

2. const int Fuction1 (int); // 此处返回 const 值，意思指返回的原函数里的变量的初值不能被修改，但是函数按值返回的这个变量被制成副本，能不能被修改就没有了意义，它可以被赋给任何的 const 或非 const 类型变量，完全不需要加上这个 const 关键字。但这只对于内部类型而言（因为内部类型返回的肯定是一个值，而不会返回一个变量，不会作为左值使用），对于用户自定义类型，返回值是常量是非常重要的，见下面条款 3 。

3.  Class CX; // 内部有构造函数，声明如 CX(int r =0)

CX  Fuction1 () { return CX(); }

const CX Fuction2 () { return CX(); }

如有上面的自定义类 CX ，和函数 Fuction1() 和 Fuction2(), 我们进行如下操作时：

Fuction1() = CX(1); // 没有问题，可以作为左值调用

Fuction2() = CX(1); // 编译错误， const 返回值禁止作为左值调用。因为左值把返回值作为变量会修改其返回值， const 声明禁止这种修改。

4.   函数中指针的 const 传递和返回：

int F1 (const char * pstr); // 作为传递的时候使用 const 修饰可以保证不会通过这个指针来修改传递参数的初值，这里在函数内部任何修改 *pstr 的企图都会引起编译错误。

const char * F2 (); // 意义是函数返回的指针指向的对象是一个 const 对象，它必须赋给一个同样是指向 const 对象的指针。

const char * const F3(); // 比上面多了一个 const ，这个 const 的意义只是在他被用作左值时有效，它表明了这个指针除了指向 const 对象外，它本身也不能被修改，所以就不能当作左值来处理。

5.   函数中引用的 const 传递：

void F1 ( const X& px); // 这样的一个 const 引用传递和最普通的函数按值传递的效果是一模一样的，他禁止对引用的对象的一切修改，唯一不同的是按值传递会先建立一个类对象的副本，然后传递过去，而它直接传递地址，所以这种传递比按值传递更有效。

** 另外只有引用的 const 传递可以传递一个临时对象，因为临时对象都是 const 属性，且是不可见的，他短时间存在一个局部域中，所以不能使用指针，只有引用的 const 传递能够捕捉到这个家伙。

6.  有一点可以注意一下

    const 为函数重载提供了一个参考。

         class A

         {

           ......

           void f(int i)       {......} file:// 一个函数

           void f(int i) const {......} file:// 上一个函数的重载

            ......

          };

        关于函数 overloading ， 不能根据返回值类型来确定

        double max( int a, int b);

        int        max( int a, int b);

        也不能根据参数的默认值来判断

        int max( int a, int b);

        int max( int a, int b, int c=12);

        一句话不能让编译器有多个选择就 ok 了

对于类

1.   首先，对于 const 的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函数体内进行初始化 const 成员变量会引起编译错误。初始化成员列表形如：

X:: X ( int ir ): r(ir) {} // 假设 r 是类 X 的 const 成员变量

2.  const 成员函数。提到这个概念首先要谈到 const 对象，正象内置类型能够定义 const 对象一样（ const int r=10; ），用户自定义类型也可以定义 const 对象 (const X px(10);) ，编译器要保证这个对象在其生命周期内不能够被改变。如果你定义了这样的一个 const 对象，那么对于这个对象的一切非 const 成员函数的调用，编译器为了保证对象的 const 特性，都会禁止并在编译期间报错。所以如果你想让你的成员函数能够在 const 对象上进行操作的话，就要把这个函数声明为 const 成员函数。假如 f( ) 是类中的成员函数的话，它的声明形如：

int f( ) const; //const 放在函数的最后，编译器会对这个函数进行检查，在这个函数中的任何试图改变成员变量和调用非 const 成员函数的操作都被视为非法

** 类的构造和析构函数都不能是 const 函数。

3.  建立了一个 const 成员函数，但仍然想用这个函数改变对象内部的数据。这样的一个要求也会经常遇到，尤其是在一个苛刻的面试考官那里。首先我们要弄清楚考官的要求，因为有两种方法可以实现，如果这位考官要求不改变原来类的任何东西，只让你从当前这个 const 成员函数入手，那么你只有使用前面提到的类型强制转换方法。实例如下：

// 假如有一个叫做 X 的类，它有一个 int 成员变量 r ，我们需要通过一个 const 成员函数 f( ) 来对这个 r 进行 ++r 操作，代码如下

void X::f( ) const

{  (const_cast<X*>(this)) -> ++r;  } // 通过 this 指针进行类型强制转换实现

另外一种方法就是使用关键字： mutable 。如果你的成员变量在定义时是这个样子的：

mutable int r ;

那么它就告诉编译器这个成员变量可以通过 const 成员函数改变。编译器就不会再理会对他的检查了。

关于 const 一些问题

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

 const A_class* c=new A_class();

 A_class* e = c;

这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针 e 指向的是一个常量，所以不正确；

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

 A_class* const c = new A_class();

 A_class* b = c;

这种方法正确，因为声明指针所指向的内容可变；

[ 思考 3] ： 这样定义赋值操作符重载函数可以吗？

const A_class& operator=(const A_class& a);

不正确；在 const A_class::operator=(const A_class& a) 中，参数列表中的 const 的用法正确，而当这样连续赋值的时侯，问题就出现了： A_class a,b,c:(a=b)=c; 因为 a.operator=(b) 的返回值是对 a 的 const 引用，不能再将 c 赋值给 const 常量。

posted on 2007-10-06 01:43 旅途 阅读(152) 评论(0)  编辑 收藏 引用 所属分类: C/C++