首页 > 程序开发 > 软件开发 > C++ >

Effective C++读书笔记(2)

2012-02-04

条款03:尽可能使用constUse const whenever possible. const允许你告诉编译器和其他程序员某值应该保持不变。 如果关键字const出现在星号左边,表示被指物是常量;如果出现在星号右边,表示指针自身是常量...

条款03:尽可能使用const

Use const whenever possible.

const允许你告诉编译器和其他程序员某值应该保持不变。

如果关键字const出现在星号左边,表示被指物是常量;如果出现在星号右边,表示指针自身是常量;如果出现在星号两边,表示被指物和指针两者都是常量。

1. char greeting[] = "Hello";

2. char* p = greeting; //non-const pointer, non-const data

3. const char* p = greeting; //non-const pointer, const data

4. char* const p = greeting; //const pointer, non-const data

5. const char* const p = greeting; //const pointer, const data

如果被指物是常量,既可以关键字const写在类型之前,又可以把它写在类型之后、星号之前。两种写法的意义等价:

1. void f1(const Widget* pw); //f1获得一个指针,指向一个常量Widget对象..

2. void f2(Widget const * pw); //f2也是

STL迭代器系以指针为底层塑模出来,所以迭代器的作用就像个T*指针。声明迭代器为const就像声明指针为const一样(即声明一个T* const 指针),表示这个迭代器不得指向不同的东西,但它所指的东西的值是可以改动的。如果希望迭代器所指的东西(数据)不可被改动(即希望STL模拟一个const T* 指针),则用const_iterator:

1. std::vector<int> vec;
2. ...
3. const std::vector<int>::iterator iter = vec.begin( ); //T* const
4. *iter = 10; //没问题,改变iter所指物
5. ++iter; //错误!iter是const
6. std::vector<int>::const_iterator cIter = vec.begin( );// const T*
7. *cIter = 10; //错误! *cIter是const
8. ++cIter; //没问题,改变cIter。
令函数返回一个常量值,往往可以降低因客户错误而造成的意外,而又不至于放弃安全性和高效性。

1. class Rational { ... };
2. const Rational operator* (const Rational& lhs,const Rational& rhs);
为什么返回一个const对象?原因是如果不这样客户就能实现这样的行为:

1. Rational a, b, c;
2. ...
3. (a * b) = c; //在a * b的成果上调用operator=
如果a和b都是内置类型,这样的代码直截了当就是不合法。而一个"良好的用户自定义类型"的特征是它们避免无端地与内置类型不兼容。将operator* 的回传值声明为const可以预防那个荒唐的赋值动作。

const成员函数

将const实施于成员函数的目的,是为了确认该成员函数可作用于const对象身上。这类成员函数可以得知哪个函数可以改动对象内容而哪个函数不行,很是重要。

两个成员函数如果只是常量性不同,可以被重载。这实在是一个重要的C++特性(前几天的面试刚碰到过):

1. class TextBlock {
2. public:
3. ...
4. const char& operator[](std::size_t position) const
5. { return text[position]; } // operator[] for const对象.
6. char& operator[](std::size_t position)
7. { return text[position]; } // operator[] for non-const对象.
8. private:
9. std::string text;
10. };
11.
12. TextBlock tb("Hello");
13. std::cout << tb[0]; //调用non-const TextBlock::operator[]
14. const TextBlock ctb("World");
15. std::cout << ctb[0]; //调用const TextBlock::operator[]
只要重载operator[]并对不同的版本给予不同的返回类型,就可以令const和non-const TextBlocks获得不同的处理:

1. std::cout << tb[0];//没问题 - 读一个non-const TextBlock
2. tb[0] = &#39;x&#39;; //没问题 - 写一个non-const TextBlock
3. std::cout << ctb[0];//没问题 - 读一个const TextBlock
4. ctb[0] = &#39;x&#39;; //错误! - 写一个const TextBlock
上述错误只因operator[] 的返回类型以致,至于operator[] 调用动作自身没问题。

请注意,non-const operator[] 的返回类型是个reference tochar,不是char。如果operator[]只是返回一个char,下面这样的句子就无法通过编译:

1. tb[0] = &#39;x&#39;;
返回类型是内置类型的函数,改动函数返回值不合法。纵使合法,C++以值传递意味被改动的其实是tb.text[0]的一个副本,不是tb.text[0]自身。

l 将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

成员函数如果是const意味什么?

bitwise const:成员函数只有在不更改对象之任何成员变量(static除外)时才可以说是const,也就是说它不更改对象内的任何一个bit。bitwise constness正是C++ 对常量性的定义,因此const成员函数不可以更改对象内任何non-static成员变量。

不幸的是许多成员函数虽然不十足具备const性质却能通过bitwise测试:

1. class CTextBlock {

2. public:

3. ...

4. char& operator[](std::size_t position) const // bitwise const声明,

5. { return pText[position]; } // 但其实不适当.跟之前相比少了一个const!

6. private:

7. char* pText;

8. };

operator[]实现代码并不更改私有变量pText,于是编译器为operator[]产出目标码,并认定它是bitwiseconst。

1. const CTextBlock cctb("Hello");//声明一个常量对象。
2. char* pc = &cctb[0];//调用const operator[]取得一个指针, 指向cctb的数据。
3. *pc = &#39;J&#39;; //cctb现在有了 "Jello" 这样的内容。
以上代码没有任何错误:创建一个常量对象并设以某值,而且只对它调用const成员函数。但终究还是改变了它的值。

这种情况导出所谓的logical constness:一个const成员函数可以修改它所处理的对象内的某些bits,但只有在客户端侦测不出的情况下才得如此,也就是自己可以改用户不能改。

1. class CTextBlock {
2. public:
3. ...
4. std::size_t length() const;
5. private:
6. char* pText;
7. std::size_t textLength; //最近一次计算的文本区块长度。
8. bool lengthIsValid; //目前的长度是否有效。
9. };
10. std::size_t CTextBlock::length() const
11. {
12. if (!lengthIsValid) {
13. textLength = std::strlen(pText);
14. //错误!在const成员函数内不能对私有变量textLength进行修改
15. lengthIsValid = true;
16. //错误!在const成员函数内不能对私有变量lengthIsValid进行修改
17. }
18. return textLength; }
解决办法很简单:利用C++ 中的mutable(可变的)修饰符,mutable释放掉non-static成员变量的bitwiseconstness约束:

1. class CTextBlock {
2. public:
3. ...
4. std::size_t length() const;
5. private:
6. char* pText;
7. mutable std::size_t textLength; //这些成员变量可能总是会被更改,
8. mutable bool lengthIsValid; //即使在const成员函数内。
9. }; //现在,刚才的length函数就可以了~
l 编译器强制实施bitwise constness,但你编写程序时应该使用"概念上的常量性"(conceptual constness)。

在const和non-const成员函数中避免重复

对于"bitwise-constness非我所欲"的问题,mutable是个解决办法,但它不能解决所有的const相关难题。举个例子,假设TextBlock(和 CTextBlock)内的operator[] 不单只是返回一个reference指向某字符,也执行边界检验(boundschecking)、志记访问信息(loggedaccess info.)、甚至可能进行数据完善性检验。把所有这些同时放进const和non-const operator[] 中,导致两个版本的operator[]及大量的代码重复。

真正该做的是实现operator[]的机能一次并使用它两次,也就是说,令其中一个调用另一个。本例中constoperator[]完全做掉了non-const版本该做的一切,唯一的不同是其返回类型多了一个const资格修饰。

1. class TextBlock {
2. public:
3. ...
4. const char& operator[](std::size_t position) const //一如既往
5. {
6. ...
7. return text[position];
8. }
9. char& operator[](std::size_t position) //现在只调用const op[]
10. {
11. return
12. const_cast<char&>( //将op[]返回值的const转除
13. static_cast<const TextBlock&>(*this)//为*this加上const
14. [position] //调用const op[]
15. );
16. }
17. ...
18. };
这里共有两次转型:第一次用来为 *this添加const(这使接下来调用operator[]时得以调用const版本),第二次则是从constoperator[]的返回值中移除const。

添加const的那一次转型强迫进行了一次安全转型(将non-const对象转为const对象),所以我们使用static_cast。移除const的那个动作只可以藉由const_cast完成,没有其他选择。

简单来说就是non-const版本为了调用const版本先转换常量性,应用const版本功能完毕后,为了符合non-const的返回值,再去除常量性。

const成员函数承诺绝不改变其对象的逻辑状态(logicalstate),non-const成员函数却没有这般承诺。如果在const函数内调用non-const函数,就是冒了这样的风险:你曾经承诺不改动的那个对象被改动了。这就是为什么"const成员函数调用non-const成员函数"是一种错误行为:因为对象有可能因此被改动。

l 当const和non-const成员函数有着实质等价的实现时,令non-const版本调用const版本可避免代码重复。

摘自 pandawuwyj的专栏

相关文章
最新文章
热点推荐