const的用法

1、什么是const? 
　　常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）

　　const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

3、cons有什么主要的作用？ 
　　（1）const  +变量 = 初始值。 
　　     const int Max=100;   说明Max是只读变量，“只读变量”则是在内存中开辟一个地方来存放它的值，只不过这个值由编译器限定不允许被修改。              但是Max毕竟不是常量，常量存在内存中的只读区域中。所以int Array[Max] 会报错。 

  指定类型：const char *P1="abc"; P1++; 这里*P1是不可变的，而P1是可变的所以P1++可以。P1是指向只读值“abc”的指针。也就是说，p1是个                          char*类型的只读指针。p1=“efg”;也是允许的，但是*p1=“a”；是不允许的。

  指定地址：char* const p1 = “abc”; 这里p1不可变，是指向“abc”固定内存的指针，但是*p1可变，可以改变该内存的内容。

 （2）const+返回值+函数 -------.限定函数返回值型.

const int function(); //此时const无意义

const myclassname function(); //函数返回自定义类型myclassname.

（3）函数+const---------限定函数不能改变成员变量值.

  void function()const; //常成员函数是不能改变成员变量值的函数。一般为类中的get函数。为了使成员函数的意义更加清楚，我们可在不改变对象的成员函数的函数原型中加上const说明：

int GetX() const;   const成员函数应该在函数原型说明和函数定义中都增加const限定：

int Point::GetY() const

{

return yVal;

}

非常量成员函数不能被常量成员对象调用，因为它可能企图修改常量的数据成员：

const Set s;

使用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关键字限定的，也不能被常量对象调用。下面通过一个例子来说明这个问题：

class C

{

int X;

public:

int GetX()

{

return X;

}

void SetX(int X)

{

this->X = X;

}

};

void main()

{

const C constC;

cout<<constC.GetX();

}

如果我们编译上面的程序代码，编译器会出现错误提示：constC是个常量对象，它只能调用const成员函数。虽然GetX( )函数实际上并没有改变数据成员X，由于没有const关键字限定，所以仍旧不能被constC对象调用。如果我们将上述代码中：

int GetX()

改写成：

int GetX()const

再重新编译，就没有问题了。

const成员函数的使用

const成员函数表示该成员函数只能读类数据成员，而不能修改类成员数据。定义const成员函数时，把const关键字放在函数的参数表和函数体之间。有人可能会问：为什么不将const放在函数声明前呢？因为这样做意味着函数的返回值是常量，意义完全不同。下面是定义const成员函数的一个实例：

class X

{

int i;

public:

int f() const;

};

关键字const必须用同样的方式重复出现在函数实现里，否则编译器会把它看成一个不同的函数：

int X::f() const

{

return i;

}

如果f( )试图用任何方式改变i或调用另一个非const成员函数，编译器将给出错误信息。任何不修改成员数据的函数都应该声明为const函数，这样有助于提高程序的可读性和可靠性。

（4）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。
　　例如： void f(const int i) { .........} 编译器就会知道i是一个输入意义的只读变量，不允许修改； 
　　（5）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！
　　如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！ 
　　（6）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 
　　例如： void f(const int i) { i=10;//error! } 
　　（7） 为函数重载提供了一个参考。 
　　class A { ...... 
　　void f(int i) {......} //一个函数 
　　void f(int i) const {......} //上一个函数的重载 ...... 
　　}; 
　　（8） 可以节省空间，避免不必要的内存分配。 例如： 
　　#define PI 3.14159 //常量宏 
　　const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ...... 
　　double i=Pi; //此时为Pi分配内存，以后不再分配！ 
　　double I=PI; //编译期间进行宏替换，分配内存 
　　double j=Pi; //没有内存分配 
　　double J=PI; //再进行宏替换，又一次分配内存！ 
　　const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。 
　　（9） 提高了效率。 
　　编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。