上一篇文章折腾了一波粉丝，那么这一篇文章稍微温柔一些。
我主要开始说如何正确使用const
1.不能将const 修饰的任何对象、引用和指针作为赋值表达式的左值。
const int cx=100;
const int & rcx=cx;
const int * pcx=&cx;
cx=200; //error
rcx=200; //error
*pcx=200; //error
Int& a =100; //error
2.const 类型的对象不能直接被non-const 类型的别名所引用。
(1)不能将const 类型的对象传递给non-const 类型的引用。
const int cx=100;
int & rx=cx; //error
(2)不能将const 类型的实参传递给形参为non-const 类型引用的函数。
void f(int a)
{}
void g(int & ra)
{}
const int cx=100;
f(cx); //ok
g(cx); //error
(3)不能将const 类型的对象作为non-const 类型引用的函数返回值。
int & f(const int & rca)
{
return rca; //error
}
int x=100;
f(x);
3.可以使用const 类型别名引用non-const 对象。
此时通过const 引用不能修改对象，但对象可以通过non-const 引用被修改。
int x=100;
int & rx=x;
const int & rcx=x; //ok
x=200;
rx=200;
rcx=200; //error
4.指针的属性有两个：指针的类型和指针本身的常量性。其中，指向const 对象与指向nonconst对象，是不同的指针类型。
int x=100;
const int * pcx=&x; //[1]
int * px=&x; //[2]
int y=100;
int * const cpy=&y; //[3]
int * py=&y; //[4]
[1][2]两个指针的类型不同；[3][4]两个指针的常量性不同。
对象与指向对象的指针的规则类似于对象与引用。即，const 类型的对象不能直接被nonconst
类型的指针所指示（同2）；可以使用const 类型的指针指向non-const 对象（同3）。
5.可以将相同类型（包括常量性）的const 指针值赋给non-const 指针。
int x=100;
int * px;
const int * pcx=&x;
px=pcx; //error
int * const cpx=&x;
px=cpx; //ok
6.若函数的返回值为内建类型或是指针，则该返回值自动成为const 性质。但自定义类型
则为non-const 性质。
int f() //相当于返回const int
{
return 100;
}
int * g(int & ra) //相当于返回int * const
{
return &ra;
}
class CTest
{
int n;
public:
CTest(int n){this->n=n;}
};
CTest h() //返回的就是CTest
{
return CTest(200);
}
f()=200; //error
int x=100;
int y=200;
int * px=&x;
g(y)=px; //error
*g(y)=x; //ok，从这点可以看出g()返回的不是const int *
CTest t(100);
h()=t; //ok，但却是完全错误的、危险的做法
//所以h()的正确写法是返回const CTest
const int a=100; a 的内容不变,a 只能是100（同样不能类型转换）。
int const b=100; b 必须为int 型,不能为其他类型?（同样在使用中不能修改）。
所以a 和b 是一样的，称为整型常数，在使用中不能被修改，当然都不能转为其他类型了。
#include <iostream>
using namespace std;
int main()
{
const int a = 100;
int const b = 100;
a = 100; //这四条语句编译时都会出现“Cannot modify a const object
b = 100; //in function main()”的错误提示，也就是说，任何企图修改a = 100.0; //a 和
b（其实是一样的）的行为都会出现“灾难”，在语法上讲就b = 100.0; //是a 和b 都不
能出现在赋值语句的左边！
cout<<'\n'<<a<<'\n'<<b<<endl;
return 0;
}
常函数的调用
常函数的调用是这样的：常量对象只能调用常成员函数，非常量对象即可以调常成员函数，
也可以调一般成员函数，但当某个函数有const 和非const 两个版本时，const 对象调const
版本，非const 对象调非const 版本
例：
A a;
a.GetData();//调用int & GetData(){return data;}
//但如果没有这个函数，也可以调用const int & GetData()const
const A const_a;
const_a.GetData();//调用const int & GetData()const {return data;}
常函数只能调常函数，也是由于这个原因
这里我插一嘴，我面试C++的时候经常会问到面试者这样一个问题：类成员函数在后边通过const修饰和不用const修饰的区别是什么，我想你现在应该能回答上来了吧。实际上通过const修饰的成员方法为常方法，常量成员函数确保不会修改任何非静态成员变量的值。编译器如果发现常量成员函数内出现了有可能修改非静态成员变量的语句，就会报错。因此，常量成员函数内部也不允许调用同类的其他非常量成员函数（静态成员函数除外）。
