Const用法
2013-11-12 14:53
211 查看
Const的使用,认为可有可无,如果你开发的是一个简单的系统,如果你一个人就能记住所有变量的意义,如果你一个人就能控制所有变量的使用位置,如果你的软件发布后不需要更多的维护工作,那么你可以忘记const,否则,const就是一个多个程序员之间沟通的强大工具。
首先,const的最基本用法就是标识常量,使编译器能够检测出对该变量的不正确使用,也可以使其他的程序员使用此常量时,注意不能改变此常量。const出现在不同的位置有不同的意义。
1. const int number = 1; // 该变量为常量,以后不能再对它赋值,所以这里必须赋初值
2. const int * pNumber; // 指向常量的指针,(*pNumber)的值不能改变,但指针pNumber的值可以改变
3. int * const pNumber = & number2; // 指向变量的常量指针,指针的值不能改变,所以必须先初始化
4. const int * const pNumber = & number; // 指向常量的常量指针,常量和指针的值都不能改变,所以必须先初始化
5. const int & number1 = number; // 指向常量的引用,C++中所有的引用都是常量引用,一个引用指向一个变量后,不能再改变值指向另一个变量,所以不论是否说明,引用都是常量引用,必须在初始化时赋初值
其次,C++对函数的参数不区分输入参数和输出参数,而且经常由于一个返回值不够用,我们会传递几个引用或指针来接收返回值。我们可以用const来标明某参数为输入参数,函数内不会改变此参数的值,如下面一个函数:
bool CopyClass(Value & dest, const Value & src);
其中,Value为用户定义的类,CopyClass函数的功能为拷贝src的内容到dest,src为输入参数,其值不能被改变,dest为输出参数,其他程序员根据函数的定义,就能对函数的功能有个清晰的了解。
下面,让我们来看一下const的最后一种用法。请看下面CopyClass函数和Value类的实现:
class Value {
public:
int GetValue() { return _value; }
private:
int _value;
}
bool CopyClass(Value & dest, const Value & src) {
int v = src.GetValue();
…………
}
请问:这段代码能编译通过吗?测试一下,果然出现了编译错误,错误出现在下面语句:int v = src.GetValue(); // 编译错误,由于src为指向常量的引用,编译器无法确定GetValue函数是否改变了src的内容,所以禁止调用.那么,我们只能放弃使用const标识输入参数了吗?不,我们另有办法,只要把GetValue函数的定义作如下改变即可:
int GetValue() const { return _value; } // const表示对传递给它的this指针指向的内容(即Value类)不做任何改变经过这样的改变,上述代码就能编译通过了,其他的程序员也可以很快的了解到,该成员函数只是输出类对象的内容,不会改变类对象的任何内容。
------------------------------------------------------------------------------------------------
const主要是为了程序的健壮型,减少程序出错.
最基本的用法:
const int a=100; b的内容不变,b只能是100也就是声明一个int类型的常量(#define b =100)
int const b=100; //和上面作用一样
const指针和引用一般用在函数的参数中
int* m = &a; //出错,常量只能用常指针
int c= 1;
const int*pc = &c;//常指针可指向常量
const int* pa = &a; //指针指向的内容为常量(就是b的值不变)
int const *a = &b; //指针指向的内容为常量(就是b的值不变)*p=3//error
int* const a = &b; //指针为常量,不能更改指针了如 a++但可以改值*p=3;
------------------------------------------------
从这可以看出const放在*左侧修饰的是指针的内容,const放在*右侧修饰的是指针
本身.
--------------------------------------------------
const引用的用法和指针一样
int const & a=b; 和指针一样
const int& a=b; 和指针一样
但没有 int& const a=b 的用法因为引用不能做移位运算,但只是出个warning
---------------------------------------------------------------------------------------------
const int* const a = &b; //综合应用,一般用来传递多维的数组
类如: char* init[] = {"Paris","in the","Spring"};
void fun(const int* const a){}
fun(init)//保护参数不被修改
------------------------------------------------------------------------
int A(int)const; //是常函数,只能用在类中,调用它的对象不能改改变成员值
const int A(); //返回的是常量,所以必须这么调用 cosnt int a=A();
int A(const int); //参数不能改值,可用在任意函数
int A(const int*);
....
int height() const;//常函数只能由常函数调用
int max(int,int) const;
int Max = max(height(),height());
-----------------------------------------------------------
const int* pHeap = new int;
delete pHeap;
p = NULL;//出错
我的解决办法是强制类型转换
const int* pHeap = new int(1);
delete (int*)pHeap;
pHeap = NULL;
-------------const修饰函数---------------------------
看到const 关键字,C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量,那么相当于把火药仅用于***鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。
const 是constant 的缩写,“恒定不变”的意思。被const 修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。所以很多C++程序设计书籍建议:“Use const whenever you need”。
1.用const 修饰函数的参数
如果参数作输出用,不论它是什么数据类型,也不论它采用“指针传递”还是“引用传递”,都不能加const 修饰,否则该参数将失去输出功能。const 只能修饰输入参数:
如果输入参数采用“指针传递”,那么加const 修饰可以防止意外地改动该指针,起到保护作用。
例如StringCopy 函数:
void StringCopy(char *strDestination, const char *strSource);
其中strSource 是输入参数,strDestination 是输出参数。给strSource 加上const修饰后,如果函数体内的语句试图改动strSource 的内容,编译器将指出错误。
如果输入参数采用“值传递”,由于函数将自动产生临时变量用于复制该参数,该输入参数本来就无需保护,所以不要加const 修饰。
例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。
对于非内部数据类型的参数而言,象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a,而临时对象的构造、复制、析构过程都将消耗时间。
为了提高效率,可以将函数声明改为void Func(A &a),因为“引用传递”仅借用一下参数的别名而已,不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点:
“引用传递”有可能改变参数a,这是我们不期望的。解决这个问题很容易,加const修饰即可,因此函数最终成为void Func(const A &a)。
以此类推,是否应将void Func(int x) 改写为void Func(const int &x),以便提高效率?完全没有必要,因为内部数据类型的参数不存在构造、析构的过程,而复制也非常快,“值传递”和“引用传递”的效率几乎相当。
问题是如此的缠绵,我只好将“const &”修饰输入参数的用法总结一下。
对于非内部数据类型的输入参数,应该将“值传递”的方式改为“const 引用传递”,目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
对于内部数据类型的输入参数,不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的,又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
2 .用const 修饰函数的返回值
如果给以“指针传递”方式的函数返回值加const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。例如函数
const char * GetString(void);
如下语句将出现编译错误:
char *str = GetString();
正确的用法是
const char *str = GetString();
如果函数返回值采用“值传递方式”,由于函数会把返回值复制到外部临时的存储单元中,加const 修饰没有任何价值。
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数A GetA(void) 写成const A GetA(void),其中A 为用户自定义的数据类型。
如果返回值不是内部数据类型,将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心,一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了,否则程序会出错。
函数返回值采用“引用传递”的场合并不多,这种方式一般只出现在类的赋值函数中,目的是为了实现链式表达。
例如:
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 则是非法的。
3. const 成员函数
任何不会修改数据成员(即函数中的变量)的函数都应该声明为const 类型。如果在编写const 成员函数时,不慎修改了数据成员,或者调用了其它非const 成员函数,编译器将指出错误,这无疑会提高程序的健壮性。以下程序中,类stack 的成员函数GetCount 仅用于计数,从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。
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;
}
const 成员函数的声明看起来怪怪的:const 关键字只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。
关于Const函数的几点规则:
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的
首先,const的最基本用法就是标识常量,使编译器能够检测出对该变量的不正确使用,也可以使其他的程序员使用此常量时,注意不能改变此常量。const出现在不同的位置有不同的意义。
1. const int number = 1; // 该变量为常量,以后不能再对它赋值,所以这里必须赋初值
2. const int * pNumber; // 指向常量的指针,(*pNumber)的值不能改变,但指针pNumber的值可以改变
3. int * const pNumber = & number2; // 指向变量的常量指针,指针的值不能改变,所以必须先初始化
4. const int * const pNumber = & number; // 指向常量的常量指针,常量和指针的值都不能改变,所以必须先初始化
5. const int & number1 = number; // 指向常量的引用,C++中所有的引用都是常量引用,一个引用指向一个变量后,不能再改变值指向另一个变量,所以不论是否说明,引用都是常量引用,必须在初始化时赋初值
其次,C++对函数的参数不区分输入参数和输出参数,而且经常由于一个返回值不够用,我们会传递几个引用或指针来接收返回值。我们可以用const来标明某参数为输入参数,函数内不会改变此参数的值,如下面一个函数:
bool CopyClass(Value & dest, const Value & src);
其中,Value为用户定义的类,CopyClass函数的功能为拷贝src的内容到dest,src为输入参数,其值不能被改变,dest为输出参数,其他程序员根据函数的定义,就能对函数的功能有个清晰的了解。
下面,让我们来看一下const的最后一种用法。请看下面CopyClass函数和Value类的实现:
class Value {
public:
int GetValue() { return _value; }
private:
int _value;
}
bool CopyClass(Value & dest, const Value & src) {
int v = src.GetValue();
…………
}
请问:这段代码能编译通过吗?测试一下,果然出现了编译错误,错误出现在下面语句:int v = src.GetValue(); // 编译错误,由于src为指向常量的引用,编译器无法确定GetValue函数是否改变了src的内容,所以禁止调用.那么,我们只能放弃使用const标识输入参数了吗?不,我们另有办法,只要把GetValue函数的定义作如下改变即可:
int GetValue() const { return _value; } // const表示对传递给它的this指针指向的内容(即Value类)不做任何改变经过这样的改变,上述代码就能编译通过了,其他的程序员也可以很快的了解到,该成员函数只是输出类对象的内容,不会改变类对象的任何内容。
------------------------------------------------------------------------------------------------
const主要是为了程序的健壮型,减少程序出错.
最基本的用法:
const int a=100; b的内容不变,b只能是100也就是声明一个int类型的常量(#define b =100)
int const b=100; //和上面作用一样
const指针和引用一般用在函数的参数中
int* m = &a; //出错,常量只能用常指针
int c= 1;
const int*pc = &c;//常指针可指向常量
const int* pa = &a; //指针指向的内容为常量(就是b的值不变)
int const *a = &b; //指针指向的内容为常量(就是b的值不变)*p=3//error
int* const a = &b; //指针为常量,不能更改指针了如 a++但可以改值*p=3;
------------------------------------------------
从这可以看出const放在*左侧修饰的是指针的内容,const放在*右侧修饰的是指针
本身.
--------------------------------------------------
const引用的用法和指针一样
int const & a=b; 和指针一样
const int& a=b; 和指针一样
但没有 int& const a=b 的用法因为引用不能做移位运算,但只是出个warning
---------------------------------------------------------------------------------------------
const int* const a = &b; //综合应用,一般用来传递多维的数组
类如: char* init[] = {"Paris","in the","Spring"};
void fun(const int* const a){}
fun(init)//保护参数不被修改
------------------------------------------------------------------------
int A(int)const; //是常函数,只能用在类中,调用它的对象不能改改变成员值
const int A(); //返回的是常量,所以必须这么调用 cosnt int a=A();
int A(const int); //参数不能改值,可用在任意函数
int A(const int*);
....
int height() const;//常函数只能由常函数调用
int max(int,int) const;
int Max = max(height(),height());
-----------------------------------------------------------
const int* pHeap = new int;
delete pHeap;
p = NULL;//出错
我的解决办法是强制类型转换
const int* pHeap = new int(1);
delete (int*)pHeap;
pHeap = NULL;
-------------const修饰函数---------------------------
看到const 关键字,C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量,那么相当于把火药仅用于***鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值,甚至函数的定义体。
const 是constant 的缩写,“恒定不变”的意思。被const 修饰的东西都受到强制保护,可以预防意外的变动,能提高程序的健壮性。所以很多C++程序设计书籍建议:“Use const whenever you need”。
1.用const 修饰函数的参数
如果参数作输出用,不论它是什么数据类型,也不论它采用“指针传递”还是“引用传递”,都不能加const 修饰,否则该参数将失去输出功能。const 只能修饰输入参数:
如果输入参数采用“指针传递”,那么加const 修饰可以防止意外地改动该指针,起到保护作用。
例如StringCopy 函数:
void StringCopy(char *strDestination, const char *strSource);
其中strSource 是输入参数,strDestination 是输出参数。给strSource 加上const修饰后,如果函数体内的语句试图改动strSource 的内容,编译器将指出错误。
如果输入参数采用“值传递”,由于函数将自动产生临时变量用于复制该参数,该输入参数本来就无需保护,所以不要加const 修饰。
例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。
对于非内部数据类型的参数而言,象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a,而临时对象的构造、复制、析构过程都将消耗时间。
为了提高效率,可以将函数声明改为void Func(A &a),因为“引用传递”仅借用一下参数的别名而已,不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点:
“引用传递”有可能改变参数a,这是我们不期望的。解决这个问题很容易,加const修饰即可,因此函数最终成为void Func(const A &a)。
以此类推,是否应将void Func(int x) 改写为void Func(const int &x),以便提高效率?完全没有必要,因为内部数据类型的参数不存在构造、析构的过程,而复制也非常快,“值传递”和“引用传递”的效率几乎相当。
问题是如此的缠绵,我只好将“const &”修饰输入参数的用法总结一下。
对于非内部数据类型的输入参数,应该将“值传递”的方式改为“const 引用传递”,目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
对于内部数据类型的输入参数,不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的,又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
2 .用const 修饰函数的返回值
如果给以“指针传递”方式的函数返回值加const 修饰,那么函数返回值(即指针)的内容不能被修改,该返回值只能被赋给加const 修饰的同类型指针。例如函数
const char * GetString(void);
如下语句将出现编译错误:
char *str = GetString();
正确的用法是
const char *str = GetString();
如果函数返回值采用“值传递方式”,由于函数会把返回值复制到外部临时的存储单元中,加const 修饰没有任何价值。
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数A GetA(void) 写成const A GetA(void),其中A 为用户自定义的数据类型。
如果返回值不是内部数据类型,将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心,一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了,否则程序会出错。
函数返回值采用“引用传递”的场合并不多,这种方式一般只出现在类的赋值函数中,目的是为了实现链式表达。
例如:
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 则是非法的。
3. const 成员函数
任何不会修改数据成员(即函数中的变量)的函数都应该声明为const 类型。如果在编写const 成员函数时,不慎修改了数据成员,或者调用了其它非const 成员函数,编译器将指出错误,这无疑会提高程序的健壮性。以下程序中,类stack 的成员函数GetCount 仅用于计数,从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount 函数中的错误。
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;
}
const 成员函数的声明看起来怪怪的:const 关键字只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。
关于Const函数的几点规则:
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的
相关文章推荐
- C++(typedef、一维数组转成二维数组、C和C++区别、成员地址成员指针、构造析构函数、this指针、const用法、显示时间、const用法)
- C++ 第九章 关于类和对象的进一步讨论(二)const的用法和指针数据成员
- 函数声明后面的const用法
- const的常见基本用法
- C++中const、volatile、mutable的用法
- CONST的用法小结:
- const 用法及常见错误
- C++:const用法的简单总结
- C语言中const的用法
- C++学习--const用法总结
- C++const关键字用法
- const用法荟萃(一)
- const 的用法
- C#中const 和 readonly 修饰符的用法详解
- C/C++中的const和const指针的基本用法
- 关于const的用法
- const用法小结
- C++ 关键字 const 的用法小结
- 话说C语言const用法
- C++ const用法