const!~(

C++常类型(const)

2001-08-06· ·--··pcvc

　　常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。因此，定义或说明常类型时必须进行初始化。

　　一般常量和对象常量

　　1. 一般常量

　　一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。如：

　　int const x=2;

　　或

　　const int x=2;

　　定义或说明一个常数组可采用如下格式：

　　<类型说明符> const <数组名>[<大小>]…

　　或者

　　const <类型说明符> <数组名>[<大小>]…

　　例如：

　　int const a[5]={1, 2, 3, 4, 5};

　　2. 常对象

　　常对象是指对象常量，定义格式如下：

　　<类名> const <对象名>

　　或者

　　const <类名> <对象名>

　　定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。

　　常指针和常引用

　　1. 常指针

　　使用const修饰指针时，由于const的位置不同，而含意不同。下面举两个例子，说明它们的区别。

　　下面定义的一个指向字符串的常量指针：

　　char * const prt1 = stringprt1;

　　其中，ptr1是一个常量指针。因此，下面赋值是非法的。

　　ptr1 = stringprt2;

　　而下面的赋值是合法的：

　　*ptr1 = "m";

　　因为指针ptr1所指向的变量是可以更新的，不可更新的是常量指针ptr1所指的方向(别的字符串)。

　　下面定义了一个指向字符串常量的指针：

　　const * ptr2 = stringprt1;

　　其中，ptr2是一个指向字符串常量的指针。ptr2所指向的字符串不能更新的，而ptr2是可以更新的。因此，

　　*ptr2 = "x";

　　是非法的，而：

　　ptr2 = stringptr2;

　　是合法的。

　　所以，在使用const修饰指针时，应该注意const的位置。定义一个指向字符串的指针常量和定义一个指向字符串常量的指针时，const修饰符的位置不同，前者const放在*和指针名之间，后者const放在类型说明符前。

　　2. 常引用

　　使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：

　　const <类型说明符> & <引用名>

　　例如：

　　const double & v;

　　在实际应用中，常指针和常引用往往用来作函数的形参，这样的参数称为常参数。

　　在C++面向对象的程序设计中，指针和引用使用得较多，其中使用const修饰的常指针和常引用用得更多。使用常参数则表明该函数不会更新某个参数所指向或所引用的对象，这样，在参数传递过程中就不需要执行拷贝初始化构造函数，这将会改善程序的运行效率。

　　下面举一例子说明常指针作函数参数的作法。

#include
const int N = 6;
void print(const int *p, int n);

void main()
{
int array[N];
for (int i=0; i cin>>array[i];
print(array, N);
}

void print(const int *p, int n)
{
cout<<"{"<<*p;
for (int i=1; i cout<<","<<*(p+i);
cout<<"}"< }

　　常成员函数

　　使用const关键字进行说明的成员函数，称为常成员函数。只有常成员函数才有资格操作常量或常对象，没有使用const关键字说明的成员函数不能用来操作常对象。常成员函数说明格式如下：

　　<类型说明符> <函数名> (<参数表>) const；

其中，const是加在函数说明后面的类型修饰符，它是函数类型的一个组成部分，因此，在函数实现部分也要带const关键字。下面举一例子说明常成员函数的特征。

#include
class R
{
public:
R(int r1, int r2) { R1=r1; R2=r2; }
void print();
void print() const;
private:
int R1, R2;
};

void R::print()
{
cout< }

void R::print() const
{
cout< }

void main()
{
R a(5, 4);
a.print();
const R b(20, 52);
b.print();
}

　　该例子的输出结果为：

　　5,4
　　20;52

　　该程序的类声明了两个成员函数，其类型是不同的(其实就是重载成员函数)。有带const修饰符的成员函数处理const常量，这也体现出函数重载的特点。

　　常数据成员

　　类型修饰符const不仅可以说明成员函数，也可以说明数据成员。

　　由于const类型对象必须被初始化，并且不能更新，因此，在类中说明了const数据成员时，只能通过成员初始化列表的方式来生成构造函数对数据成员初始化。

　　下面通过一个例子讲述使用成员初始化列表来生成构造函数。

#include
class A
{
public:
A(int i);
void print();
const int &r;
private:
const int a;
static const int b;
};

const int A::b=10;
A::A(int i):a(i), r(a)
{
}

void A::print()
{
cout< }

void main()
{
A a1(100), a2(0);
a1.print();
a2.print();
}

　　该程序的运行结果为：

　　100:10:100
　　　0:10:0

　　在该程序中，说明了如下三个常类型数据成员：

　　const int & r;

　　const int a;

　　static const int b;

　　其中，r是常int型引用，a是常int型变量，b是静态常int型变量。

　　程序中对静态数据成员b进行初始化。

　　值得注意的是构造函数的格式如下所示：

　　A(int i):a(i),r(a)
　　{
　　}

　　其中，冒号后边是一个数据成员初始化列表，它包含两个初始化项，用逗号进行了分隔，因为数据成员a和r都是常类型的，需要采用初始化格式。