1. 限定符声明变量只能被读
- const int i=5;
- int j=0;
- i=j; //非法,导致编译错误
- j=i; //合法
2. 必须初始化
- const int i=5; //合法
- const int j; //非法,导致编译错误
3. 在另一连接文件中引用const常量
- </pre><pre style="BACKGROUND-COLOR: rgb(240,240,240); MARGIN: 4px 0px" class="cpp" name="code">extern const int i; //合法
- extern const int j=10; //非法,常量不可以被再次赋值
4. 用const方法可以使编译器对处理内容有更多了解,便于进行类型检查。
- #define I=10
- const long &i=10;
- /*由于编译器的优化,使得在const long i=10; 时i不被分配内存,而是已10直接代入以后的引用中,以致在以后的代码中没有错误,为达到说教效果,特别地用&i明确地给出了i的内存分配。不过一旦你关闭所有优化措施,即使const long i=10;也会引起后面的编译错误。*/
- char h=I; //没有错
- char h=i; //编译警告,可能由于数的截短带来错误赋值。
5. 可以避免不必要的内存分配
由于const定义常量从汇编的角度来看,只是给出了对应的内存地址, 而不是象#define一样给出的是立即数,所以,const定义的常量在程序运行过程中只有一份拷贝,而#define定义的常量在内存中有若干个拷贝。
- #define STRING "abcdefghijklmn\n"
- const char string[]="abcdefghijklm\n";
- printf(STRING); //为STRING分配了第一次内存
- printf(string); //为string一次分配了内存,以后不再分配
- printf(STRING); //为STRING分配了第二次内存
- printf(string);
6. 可以通过函数对常量进行初始化
- int value();
- const int i=value();/*假定对ROM编写程序时,由于目标代码的不可改写,本语句将会无效,不过可以变通一下*/
- const int &i=value();/* 只要令i的地址处于ROM之外,即可实现:i通过函数初始化,而其 值有不会被修改。*/
8. 请分清数值常量和指针常量
- int ii=0;
- const int i=0; //i是常量,i的值不会被修改
- const int *p1i=&i; //指针p1i所指内容是常量,可以不初始化
- int * const p2i=&ii //指针p2i是常量,所指内容可修改
- const int * const p3i=&i; //指针p3i是常量,所指内容也是常量
- p1i=ⅈ //合法
- *p2i=100; //合法
关于第8点要着重说明一下,第三行定义了一个常量指针,意思是指针指向的内容是不可以变的,也就是说只有常量的地址才能付给常量指针,但是在VS2008中,变量也可以赋给常量指针,
#include<iostream>
using namespace std;
int main()
{
int a=5;
const int *b=&a;
a++;
cout<<*b<<endl;
return 0;
}
如上程序编译也会通过,不知道为何,请高手指点!!!
9. const常量,如const int max = 100;
优点:const常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安全检查,而对后者只进行字符替换,没有类型安全检查,并且在字符替换时可能会产生意料不到的错误(边际效应)
10. const 修饰类的数据成员。
const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的。因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员,因为类的对象未被创建时,编译器不知道const 数据成员的值是什么。如
using namespace std;
class A
{
private:
const int a;
public:
A(int x):a(x)
{
cout<<"construct!"<<endl;
}
void print()
{
cout<<a<<endl;
}
};
int main()
{
A b(5);
b.print();
A c(4);
// c=b;//错误,operator=在A中不可用
return 0;
}
const数据成员的初始化只能在类的构造函数的初始化表中进行。另外类中包含const常量不能用=复制类,如上例。要想建立在整个类中都恒定的常量,应该用类中的枚举常量来实现。枚举常量不会占用对象的存储空间,他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数,其最大值有限,且不能表示浮点数。如:
- class A
- {
- enum {size1=100, size2 = 200 };
- int array1[size1];
- int array2[size2];
- }
12. const的初始化
1) 非指针const常量初始化的情况:
- A b;
- const A a = b;
2) 指针const常量初始化的情况:
- A* d = new A();
- const A* c = d;
- 或者:const A* c = new A();
3)引用const常量初始化的情况:
- A f;
- const A& e = f; // 这样作e只能访问声明为const的函数,而不能访问一般的成员函数;
13. 另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中,const 可以修饰函数的返回值,或某个参数;对于成员函数,还可以修饰是整个函数。有如下几种情况,以下会逐渐的说明用法:
- A& operator=(const A& a);
- void fun0(const A* a );
- void fun1( ) const; // fun1( ) 为类成员函数
- const A fun2( );
1) 修饰参数的const,如 void fun0(const A* a ); void fun1(const A& a);
调用函数的时候,用相应的变量初始化const常量,则在函数体中,按照const所修饰的部分进行常量化,如形参为const A* a,则不能对传递进来的指针的内容进行改变,保护了原指针所指向的内容;如形参为const A& a,则不能对传递进来的引用对象进行改变,保护了原对象的属性。
[注意]:参数const通常用于参数为指针或引用的情况,且只能修饰输入参数;若输入参数采用“值传递”方式,由于函数将自动产生临时变量用于复制该参数,该参数本就不需要保护,所以不用const修饰。
[总结]:对于非内部数据类型的输入参数,因该将“值传递”的方式改为“const引用传递”,目的是为了提高效率。例如,将void Func(A a)改为void Func(const A &a)
对于内部数据类型的输入参数,不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的,又降低了函数的可理解性。例如void Func(int x)不应该改为void Func(const int &x)
2) 修饰返回值的const,如const A fun2( ); const A* fun3( );
这样声明了返回值后,const按照"修饰原则"进行修饰,起到相应的保护作用。
- const Rational operator*(const Rational& lhs, const Rational& rhs)
- {
- return Rational(lhs.numerator() * rhs.numerator(),
- lhs.denominator() * rhs.denominator());
- }
返回值用const修饰可以防止允许这样的操作发生:
- Rational a,b;
- Radional c;
- (a*b) = c;
一般用const修饰返回值为对象本身(非引用和指针)的情况多用于二目操作符重载函数并产生新对象的时候。
[总结]
一般情况下,函数的返回值为某个对象时,如果将其声明为const时,多用于操作符的重载。通常,不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下:如果返回值为某个对象为const(const A test = A 实例)或某个对象的引用为const(const A& test = A实例) ,则返回值具有const属性,则返回实例只能访问类A中的公有(保护)数据成员和const成员函数,并且不允许对其进行赋值操作,这在一般情况下很少用到。
如果给采用“指针传递”方式的函数返回值加const修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。如:const char * GetString(void);如下语句将出现编译错误:char *str=GetString();正确的用法是:const char *str=GetString();
函数返回值采用“引用传递”的场合不多,这种方式一般只出现在类的赙值函数中,目的是为了实现链式表达。如:
- class A
- {
- A &operate = (const A &other); //负值函数
- }
- A a,b,c; //a,b,c为A的对象
- a=b=c; //正常
- (a=b)=c; //不正常,但是合法
若负值函数的返回值加const修饰,那么该返回值的内容不允许修改,上例中a=b=c依然正确。(a=b)=c就不正确了。
14. 类成员函数中const的使用
一般放在函数体后,形如:void fun() const;
任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时,不慎修改了数据成员,或者调用了其他非const成员函数,编译器将报错,这大大提高了程序的健壮性。如:
- class Stack
- {
- public:
- void Push(int elem);
- int Pop(void);
- int GetCount(void) const; //const 成员函数
- private:
- int m_num;
- int m_data[100];
- };
- int Stack::GetCount(void) const
- {
- ++m_num; //编译错误,企图修改数据成员m_num
- Pop(); //编译错误,企图调用非const函数
- Return m_num;
- }
15. 使用const的一些建议
要大胆的使用const,这将给你带来无尽的益处,但前提是你必须搞清楚原委;要避免最一般的赋值操作错误,如将const变量赋值,具体可见思考题;
在参数中使用const应该使用引用或指针,而不是一般的对象实例,原因同上;
const在成员函数中的三种用法(参数、返回值、函数)要很好的使用;
不要轻易的将函数的返回值类型定为const;
除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;
16. 一些思考题
[思考1]: 以下的这种赋值方法正确吗?
const A* c=new A();
A* e = c;
[思考2]: 以下的这种赋值方法正确吗?
A* const c = new A();
A* b = c;
[思考3]: 这样定义赋值操作符重载函数可以吗?
const A& operator=(const A& a);
1 这种方法不正确,因为声明指针的目的是为了对其指向的内容进行改变,而声明的指针e指向的是一个常量,所以不正确;
2 这种方法正确,因为声明指针所指向的内容可变;
3 这种做法不正确;
在const A::operator=(const A& a)中,参数列表中的const的用法正确,而当这样连续赋值的时侯,问题就出现了:
A a,b,c:
(a=b)=c;
因为a.operator=(b)的返回值是对a的const引用,不能再将c赋值给const常量。
- class A
- {
- public:
- int x;
- mutable int y;
- A(int a, int b):x(a),y(b){}
- };
- int main()
- {
- const A a(1,2);//const对象必须初始化
- a.x = 3;//错误
- a.y = 3;//正确
- return 0;
- }
20.const成员函数返回的引用,也是const
例:
- /*从const成员函数返回的引用也是const*/
- #include<iostream>
- using namespace std;
- class A
- {
- public:
- int x;
- void set(int x){this->x = x;}
- /*const成员函数返回的引用也是const,a
- 如果把A&前面的const去掉会出错。
- 因为返回的是一个const的对象,返回类型却不是const
- 返回的内容和返回的类型不符*/
- const A& Test1()const
- {
- /*错误。这是const成员函数的特点*/
- x = 2;
- /*不限于*this。不管返回的是什么,哪怕是一个定义为非const的对象,结果也是一样的*/
- return *this;
- }
- };
- int main()
- {
- A a, b;
- /*正确,虽然返回的是一个const,却用另一个非const来接收*/
- b = a.Test1();
- /*错误,既然是别名,那么别名的类型要与原来的类型相同*/
- A &c = a.Test1();
- //正确虽然在a.Test1()中a不能改变,但是这里已经出了这个成员函数的作用域
- a.set(2);
- //正确,b接收了a.Test1()返回的数据的内容,但是它不是const
- b.set(2);
- /*错误。a.Test1()是一个对象,这个对象是它的返回值,
- 虽然没有名字,但是它就是a.Test1()的返回值,
- 值是a.Test1()返回的值,类型是a.Test1()返回的类型,
- 因此它是const*/
- a.Test1().set(2);
- return 0;
- }