【C/C++】const用法总结

变量主要有作用域、生存期和操作权限。const 主要是限制变量的作用权限。

1. 修饰变量
   修饰变量表明该变量为常量，无法修改。（此处叫为常量不太严谨，应该叫做只读数据，const修饰的数据仍然存放在读写数据区，可以通过指针来操作数据）

const int N=100;
const double pai=3.1415926;
N=1;			 //错误，无法修改
pai=3.14;  //错误，无法修改
cout<<N<<" "<<pai<<endl;  //正确，可以输出
int  const N=100;		//正确，const int N 和int  const N等效
double const pai=3.1415926;

2. 修饰引用
   常引用可以是普通变量的引用，也可以是常量的引用。一般引用不能作为常量的引用。不能通过常引用来改变变量的值。

int a=3;
const int b=5;
const int &c=a;  //正确，常引用可以是普通变量的引用，也可以是常量的引用。
const int &d=b; //正确，常引用可以是普通变量的引用，也可以是常量的引用
a=10;  		.//正确
c=11;  			//错误，不能通过常引用来改变变量的值。
int &e=b; 		//错误，一般引用不能作为常量的引用

3. 修饰指针——常内容指针（不允许解指针）
   const char *pContent——常内容指针，指针变量所指内容无法改变，但指针变量可以改变。

char s1[100],s2[100];
const char *pContent=s1;
pContent=s2;  //正确，指针变量可以改变
pContent[0]='a'; *pContent='a';  //错误，指针变量所指内容无法改变

4. 修饰指针——常指针
   char const *pContent——常指针，指针变量无法改变，但指针变量所指内容可以改变。pContent是常量
   等价写法
   (char) const pContent;
   const (char) pContent;

char s1[100],s2[100];
char * const pContent=s1;
*pContent='a';  	//正确，指针变量所指内容可以改变
pContent=s2;  		//错误，指针变量无法改变

常内容常指针
const char* const pContent——常内容常指针，指针变量无法改变，但指针变量所指内容无法改变

har s1[100]="1234",s2[100];
const char* const pContent=s1;
s1[0]='a'; s2[0]='1';  
pContent[0]='x';  		//错误，指针变量所指内容无法改变
pContent=s2; 			//错误，指针变量无法改变
cout<<s1; cout<<s2  

5. 修饰函数
   (1) 出现在返回值前面,函数返回值是一个常量。但是该返回值既可以赋值给一个常量，也可以赋值给普通变量。

const int fun1(); //
int a; a=fun1();  // 正确，可以赋值给一个普通变量
const int b=fun1();  // 正确，可以赋值给一个常量

(2) const int *fun2( int &a ); 返回常内容指针,函数返回指针只可以赋值给常内容指针，不能赋值给普通指针

const int *fun2( int &a );
int *q, c=5; 
const int *pValue; 
pValue=fun2( c );  // 正确，可以赋值给一个常内容指针
q=fun2(c); 			 // 错误，不可以赋值给一个普通指针

(3) 函数返回常指针。
与返回常量类似，可以将结果赋值给常指针、常内容指针或者普通指针。

int * const fun3(int &a); 
int a=6;
int * const pValue = fun3(a);  	//正确，可以将结果赋值给常指针
const int *r=fun3(a); 		//正确，可以将结果赋值给常内容指针
int *q =fun3(a);				 //正确，可以将结果赋值给普通指针

(4) 出现在函数形参中，来声明常量、常指针、常内容指针。用以限制函数中的操作
fun( const int N , int * const q, const int *p );

int fun4( const int a)
{
int b;
b=a+1;
//a=a+1;  		//错误，不能修改a的值
return a+b;
}

6. 修饰类对象/对象指针/对象引用

设POINT是一个类

const POINT a;	 //常量对象
const POINT * p;	//常对象的指针
POINT * const r;	//常量指针
POINT b;
CONST POINT &c=b; //常引用

常量对象，那这个对象的所有成员都不能修改；常引用，不能通过这个引用名修改对象的成员
const修饰的对象——常量对象，只能调用对象的const成员函数，不能调用非const成员函数。因为非const成员函数会有修改成员变量的企图

class POINT
{  int x,y;
public:
POINT(int a,int b){x=a;y=b;}
void f1();
void f2() const;
};
void POINT ::f1()
{ x=11;y=12; //V
cout<<"function 1 \n"; }
void POINT ::f2() const
{ //x=21;y=22; 					// 错误，不能改变对象的成员变量. 也不能调用类中任何非const成员函数
cout<<"function 2 \n"; }

int main() // 主函数
{
const POINT b(1,2);
POINT c(3,4);
c.f1();c.f2(); 			//正确
//b.f1(); 				//错误，常量对象只能访问const修饰的成员函数
b.f2(); 					//正确
const POINT *p=new POINT(5,6);		//p所指向的对象是常量
//p->f1();  			//错误，常量对象只能访问const修饰的成员函数
p->f2(); 				//正确
return 0;

7. 修饰类的成员变量
   const修饰类的成员变量，表示成员常量，不能被修改，同时它只能在初始化列表中赋值（只能在构造函数的头部进行初始化）

class A
{
private:
const int Value; 			//成员常量不能被修改
public: 
A(int x): Value(x) {		 //只能在初始化列表中赋值
//Value=10;				 //错误
}; 
};