C++的const用法

1.定义程序中频繁使用的常量


#include <iostream>


using namespace std;




const double PI=3.1415926;


int main()


{


cout<<"圆的面积是:"<<PI*3*3<<endl;


cout<<"周长是:"<<2*PI*3<<endl;


return 0;


}

和define定义宏相比，这个具有运行时检验且是类型安全的。

2.用在类成员之前修饰:


#include <iostream>


using namespace std;




class Test


{


private:


const int i;//注意这个是对象生命期内保持值不变


public:


Test(int ii):i(ii){}


void demo();




void error();//error


};




void Test::demo()


{


cout<<i*i<<endl;


}


void Test::error()


{


i=0;//error:不能修改只读成员


}


int main()


{


Test t1(10);


t1.demo();




Test t2(50);


t2.demo();


return 0;


}

这种const为我们提供了一种，为对象提供只读属性的方式，注意，const的成员是在成员初始化列表里初始化的。

3.如果是类的所有实例对象共用的常量，那么如下:


#include <iostream>




using namespace std;




class Test


{


private:


static const int i=100;//所有类实例共用


public:


Test(){};


void demo();


};




void Test::demo()


{


cout<<i<<endl;


}






int main()


{


Test t1;


t1.demo();//100




Test t2;


t2.demo();//100




return 0;


}

注意这里初始化在定义处。

4.const和指针结合使用


#include <iostream>


using namespace std;




int main()


{


int a=123;


const int *p=&a;


cout<<*p<<endl;




*p=456;//error:不能修改p执行的内存


return 0;


}

这里我们发现p指向的内容是不允许修改的，是只读的。
于是这里可看作p指向的类型是"const int"的，换句话说*p是个const int是不可变，当然并没有const int的类型。

我们交换下int和const:


#include <iostream>


using namespace std;




int main()


{


int a=123;


int const *p=&a;


cout<<*p<<endl;




*p=456;//error:不能修改p执行的内存


return 0;


}

发现和上面一样，之所以这样是因为我们怎么改都是，处在*的左侧，改变不了p指向(*可以理解为指向)的数据是个int const的，不可变的。

好那就放在*右面


#include <iostream>


using namespace std;




int main()


{


int a=123;


int* const p=&a;


cout<<*p<<endl;//123




*p=456;




cout<<a<<endl;//456


return 0;


}

现在是const p指向一个int类型的数据，这里const修饰的是指针p.
所以说是p的值不允许改变。
如:


#include <iostream>


using namespace std;




int main()


{


int a=123;


int b=789;


int* const p=&a;


cout<<*p<<endl;//123




*p=456;




cout<<a<<endl;//456




p=&b;//error:p不允许修改，只读指针


return 0;


}

自然而然的大家就能理解下面的代码了:


#include <iostream>


using namespace std;




int main()


{


int a=123;


int b=789;


const int* const p=&a;


cout<<*p<<endl;//123




*p=456;//error


p=&b;//error




return 0;


}

5.const结合引用

引用大家可能不陌生


#include <iostream>


using namespace std;




int main()


{


int a=123;


int &b=a;


b=456;//b可以看作是a的别名，指向同一个内存




cout<<a;//456


return 0;


}

有点像const指针：

比较下


#include <iostream>


using namespace std;




int main()


{


int a=123;


int &b=a;


b=456;//b可以看作是a的别名，指向同一个内存




int* const c=&a;


*c=789;




cout<<a;//789


return 0;


}

不过引用因此了指针存储地址的特性，比较隐蔽，看作别名，在c++中可是大行其道啊。常常使用。

注意：引用定义时需要初始化，而且之后不能再引用其他变量。

看一下const和引用使用:


#include <iostream>


using namespace std;




int main()


{


int a=123;


const int &b=a;




//b=456;//error:b引用的地方不可以修改




a=456;//不过通过a是可以修改的，只是说不能由b修改


return 0;


}

6.const与函数

看看这个


#include <iostream>


using namespace std;




void f(int i)


{


cout<<i*i<<endl;


}


int main()


{


int a=11;


f(a);//121




return 0;


}

这里我们的函数只是输出参数的计算值，传递参数的方式是copy方式。

接着换成引用方式:


#include <iostream>


using namespace std;




void f(int &i)


{


cout<<i*i<<endl;


}


int main()


{


int a=11;


f(a);//121




return 0;


}
换成了引用，结果没有什么变化。
但是如果参数的类型是个复杂的类型，比如自定义对象。那么引用可以节省不少在copy上所花的开销。

然而出现一个新的问题：

由于引用持有原实参同样的内存区，混参数副作用，我们的函数可能无意间修改了原对象，不仅危险而且出错时排错也比较困难，于是养成一个使用const的习惯，对于我们实现知道有些函数根本不应该修改实参时：


#include <iostream>


using namespace std;




void f(const int &i)


{


cout<<i*i<<endl;


}


int main()


{


int a=11;


f(a);//121




return 0;


}

于是
如果
void f(const int &i)
{
i=12;//error
cout<<i*i<<endl;
}
会报错的。

其实函数的返回值也可以用const限制的，什么，这个还需要吗？

看看下面的代码:


#include <iostream>


using namespace std;




int f(int &i)


{


i=12;


return i;


}


int main()


{


int a=11;




cout<<f(a);//12


return 0;


}

没有什么特殊之处吧，接着改改:


#include <iostream>


using namespace std;




int& f(int &i)


{


i=12;


return i;


}


int main()


{


int a=11;




cout<<f(a);//12


return 0;


}

返回引用，结果没什么变化吧。
但是现在f(a)返回了a的引用，可能会有被修改的危险!!!


#include <iostream>


using namespace std;




int& f(int &i)


{


i=12;


return i;


}


int main()


{


int a=11;




f(a)=33;




cout<<a;//33


return 0;


}

这里f(a)可以做左值，有时候我们并不希望这样的事情发生，于是const发挥了：


#include <iostream>


using namespace std;




const int& f(int &i)


{


i=12;


return i;


}


int main()


{


int a=11;




f(a)=33;//error


return 0;


}

7.const对象和const 成员函数


#include <iostream>


using namespace std;




class Test


{


private:


int i;


public:


Test(int ii){i=ii;};


void setVal(int i){this->i=i;}


void echoVal(){cout<<i<<endl;}


};




int main()


{


Test a(123);


a.setVal(456);


a.echoVal();//456


return 0;


}

没有什么特殊之处吧.

但是如果我们想要const Test a(123);这样的常量对象，他的成员不允许修改，编译器可以实现这些，只需标识其成员只读即可。
然而怎么知道哪些函数可以安全调用呢，默认可能他认为所有方法对自己不利，不能调用，可是我们如果想调用一些方法(这些方法实际并不会带来什么危险)怎么办呢，于是需要和其他方法区别开来，于是有了const成员函数，
const对象只能调用const成员函数(构造析构函数除外):


#include <iostream>


using namespace std;




class Test


{


private:


int i;


public:


Test(int ii){i=ii;};


void setVal(int ii){i=ii;}


void echoVal()const{cout<<i<<endl;}


};




int main()


{


const Test a(123);


a.echoVal();//123


return 0;


}