const总结

 

   最近在学C++，对const很纠结，上网找了一些资料，总结了一点东西，以下大多是在各大精华帖上找到的东西。也有一些个人谬论，如果有错希望大牛不吝赐教。

一、const 变量定义

const定义的变量为不可变的变量，不是常量

int i = 10;

int j = 15;

1、 const int a = i; //a不能被更改

a = j; //错误

2、 const int *a = &i;//*a不能被更改，即a指向的内容可以更改，a所指内存的内容不可更改。

*a = j; //错误

a = &j; //正确

3、 int const *a = &i;//同上

*a = j; //错误

a = &j; //正确

4、 int * const a = &i;//a不可被更改，即a指向内容不可更改，*a可以更改。

*a = j; //正确

a = &j; //错误

5、 int const * const a = &i;//指针和所指内容均不可以更改。

*a = j; //错误

a = &j; //错误

6、 const常量修改

是不是const的常量值一定不可以被修改呢？

  const int i=0;

  int *p=(int*)&i;

  *p=100;

  通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。

  //此时 &i 与 p地址相同，但是 cout<< i 为0，cout<< *p为100

  //原因在于const在内存的数据段，而变量在内存的堆栈段

7、为了提到效率可以使用

int fun(type TY) 替换为 int fun(const type &TY)  

为自定义类型是可以使用此方法处理，可以省去函数内部变量的赋值过程，但是内部类型是不需要使用此方法，降低了程序可读性。

 

8、 （1）如果一个变量已被声明为常变量,只能用指向常变量的指针变量指向它,

     而不能用一般的(指向非const型变量的)指针变量去指向它。如

    const char c[]="boy";    //定义const型的char数组

    const char *p1;         //定义p1为指向const型的char变量的指针变量

    p1=c;                   //合法,p1指向常变量(char数组的首元素)

    char *p2=c;             //不合法,p2不是指向常变量的指针变量

（2）指向常变量的指针变量除了可以指向常变量外,还可以指向未被声明为const的变量。

       此时不能通过此变量改变该变量的值。如:

    char c1='a';   //定义字符变量c1,它并未声明为const

    const char *p; //定义了一个指向常变量的指针变量p

    p=&c1;         //使p指向字符变量c1

    *p='b';        //非法,不能通过p改变变量c1的值

    c1='b';        //合法,没有通过p访问c1,c1不是常变量

（3）如果函数的形参是指向非const型变量的指针,实参只能用指向非const变量的指针,

    而不能用指向const变量的指针,这样,在执行函数的过程中可以改变形参指针变量所指向

    的变量(也就是实参指针所指向的变量)的值。

    如果函数的形参是指向const型变量的指针,在执行函数过程中显然不能改变指针变量所

    指向的变量的值,因此允许实参指向const变量的指针,或指向非const变量的指针。如:

    const char str[]="boy"; //str是const型数组名

    void fun(char *ptr);    //函数fun的形参是指向非const型变量的指针

    fun(str);           //调用fun函数,实参是const变量的地址,非法

    （4）*******总结:指向常变量的指针变量可以指向const和非const型的变量,而指向非const型变量

     的指针变量只能指向非const的变量。

9、 可以节省空间，避免不必要的内存分配

#define PI 3.14159         //常量宏

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

             ......

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

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

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

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

http://blog.youkuaiyun.com/Eric_Jo/archive/2009/04/30/4138548.aspx

 

二、类相关CONST

 

(1)const修饰成员变量

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

    class A

    { 

        …

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

        …

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

     } 

 

(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(); 正确

三、函数中使用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 int fun1() //这个其实无意义，因为参数返回本身就是赋值。

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

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

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

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

 

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