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;
}
{
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;
}
本文转自 xcf007 51CTO博客，原文链接：http://blog.51cto.com/xcf007/105291，如需转载请自行联系原作者
