Item 03：尽可能使用const

最新推荐文章于 2024-05-23 10:22:40 发布

onlyshi

最新推荐文章于 2024-05-23 10:22:40 发布

阅读量771

点赞数

分类专栏： Effective C++ 文章标签： C++

本文链接：https://blog.csdn.net/onlyshi/article/details/51122973

版权

Effective C++ 专栏收录该内容

10 篇文章 8 订阅

订阅专栏

Item 03： Use const whenever possible

关键字const

const允许你指定一个语义约束（也就是指定一个“不该被改动”的对象），而编译器会强制实施这项约束。如果你想让某值保持不变，就应该明确说出来，因为说出来就可以获得编译器的帮助，确保这条约束不被违反。

关键字const多才多艺。你可用它在classes外部修饰global或namespace作用域中的常量，或修饰文件、函数、或区块作用域中被声明为static的对象。你也可以用它修饰classes内部的static或non-static成员变量。面对指针，你也可以指出指针自身、指针所指物，或两者都（或都不）是const：

char greeting[] = "Hello";          
char* p = greeting;                 //non-const pointer, non-const data
const char* p = greeting;           //non-const pointer, const data
char* const p = greeting;           //const pointer, non-const data
const char* const p = greeting;     //const pointer, const data

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

如果被指物是常量，有些人会把它写在类型之后、星号之前。两种写法的意义相同，所以下列两个函数接受的参数类型是一样的：

void f1(const Widget* pw);      //f1获得一个指针，指向一个常量的Widget对象
void f2(Widget const *pw);      //f2也是

两种形式都有人用，你应该试着习惯它们。

const面对STL迭代器

STL迭代器就是以指针为根据塑模出来的，所以迭代器的作用就像个T*指针。

声明为迭代器为const就像声明指针为const一样（即声明一个T* const指针）,表示这个迭代器不得指向不同的东西，但它所指的东西的值时可以改动的。

如果你希望迭代器所指的东西不可被改动（即STL模拟出一个const T*指针），你需要的是const_iterator:

std::vector<int> vec;
...
const std::vector<int>::iterator iter = vec.begin();    //iter的作用像个T* const
*iter = 10;                                             //没问题，改变iter所指物
++iter;                                                 //错误！iter是const

const std::vector<int>::const_iterator cTter = vec.begin();  //cIter的作用像个const T*
*cTter = 10;                                                 //错误！*cIter是cosnt
++cTter;                                                     //没问题，改变cIter。

const面向函数声明

const最具威力的用法是面对函数声明时的应用。在一个函数声明式内，const可以和函数返回值、各参数、函数自身（成员函数）产生关联。

函数返回值

令函数返回一个常量值，往往可以降低因客户错误而造成的意外，而又不至于放弃安全性和高效性。举个例子：

class Rational {...};
const Rational operator* (const Rational& lhs, const Rational& rhs);

为什么返回一个const对象？原因可能如下：

Rational a,b,c;
...
(a * b) = c;                //在a * b的成果上调用operator=

也许我们不知道为什么会有人想对两个数值的乘积再做一次赋值，但我们总见过很多人无意识中少打了一个=号：

if (a * b = c) ...          //其实是想做一个比较动作！

如果a和b都是内置类型，这样的代码就是不合法。而一个“良好的自定义类型”的特征是它们应该和内置类型兼容，因此允许对两值乘积做赋值动作就没什么意思，将operator*的回传值声明为const就可以预防那个“没意思的赋值动作”。

函数形参

对于const参数，它们不过就像local const对象一样，你应该在必要使用它们的时候使用它们。除非你有需要改动参数或local对象，否则请将它们声明为const，只不过多打6个字符而已。

const成员函数

将const实施于成员函数的目的，是为了确认该成员函数可作用于const对象身上。这类成员之所以重要，两个理由：
- 它们使class接口比较容易被理解，因为，得知哪个函数可以改动对象内容而哪个不函数不行，这一点是非常重要的。
- 它们使“操作const对象”成为可能。

两个成员函数如果只是常量性不同，可以被重载。

基于成员函数是否为const，可以重载一个成员函数；同样地，基于一个指针形参（或者引用形参）是否为指向const，可以重载一个函数。const对象只能使用const成员。非const对象可以使用任一成员，但非const版本是一个更好的匹配。
———《C++ Primer》第四版 P442

bitwise constness 和 logical constness

成员函数如果是const意味着什么？这里有两个流行概念：bitwise constness（又称physical constness）和logical constness。

bitwise constness

bitwise constness阵营的人相信，成员函数只有在不更改对象的任何成员变量时才可以说是const。也就是说它不更改对象内的任何一个bit。bitwise constness正是对C++常量性的定义，因此const成员函数不可以更改对象内任何non-static成员变量。

不幸的是许多成员虽然不十足具备const性质却能通过bitwise测试。更具体地说，一个更改了“指针所指物”的成员函数虽然不能算是const，但如果只有指针（而非其所指物）隶属于对象，那么称此函数为bitwise constness不会引发编译器异议。

class CTextBlock{
public:
    ...
    char& operator[](std::siez_t position) const    //bitwise const声明，但其实不适当
    { return pText[position];}

private:
    char* pText;
};

operator[]实现代码并不更改pText。于是编译器很开心地为operator[]产生出目标码。它是bitwise const，所有编译器都这么认定，但是，这个class不适当地将其operator[]声明为const成员函数，而该函数却返回一个reference指向对象内部值，于是就：

const CTextBlock cctb("Hello")；     //声明一个常量对象。
char* pc = &cctb[0];                 //调用const operator[]取得一个指针，指向cctb的数据。
*pc = 'J';                           //cctb现在有了“Jello”这样的内容。

这其中当然不该有任何错误：你创建一个常量对象并设以某值，而且只对它调用const成员函数。但是你终究还是改变了它的值。这种情况就是所谓的logical constness。

logical constness

这一派拥护者主张，一个const成员函数可以修改它所处理的对象内的某些bits，但只有在客户端侦测不出的情况下才得如此。

class CTextBlock{
public:
    ...
    std::size_t length() const;
private:
    char* pText;
    std::size_t textLength;                //最近一次计算的文本区块长度
    bool lengthIsValid;                    //目前的长度是否有效
};
std::size_t CTextBlock::length() const
{
    if (!lengthIsValid) {
        textLength = std::strlen(pText);    //错误！在const成员函数内不能赋值给textLength
        lengthIsValid = true;               //和lengthIsValid
    }
    return textLength;
}

length的实现当然不是bitwise const，因为textLength和lengthIsValid都可能被修改。这两项成员修改对const CTextBlock对象而言虽然可接受，但编译器不同意。它们坚持bitwise constness。怎么办？
解决办法很简单：mutable（可变的）、mutable释放掉non-static成员变量的bitwise constness约束：

class CTextBlock{
public:
    ...
    std::size_t length() const;
private:
    char* pText;
    mutable std::size_t textLength;     //这些成员变量可能总是会被更改，即使在
    mutable bool lengthIsValid;         //const成员函数内
};
std::size_t CTextBlock::length() const
{
    if (!lengthIsValid) {
        textLength = std::strlen(pText);    
        lengthIsValid = true;               
    }
    return textLength;
}

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

对于“bitwise-constness非我想要”的问题，mutable是个解决办法，但它不能解决所有的const相关难题。举个例子，假设TextBlock内的operator[]不单只是返回一个reference指向某字符，也执行边界减压、日志访问信息、甚至可能进行数据完善性检验。把所有这些同时放进const和non-const operator[]中，导致这样的怪物：

class TextBlock{
public:
    ...
    const char& operator[](std::siez_t position) const
    { 
        ...         //边界检验
        ...         //日志数据访问
        ...         //检验数据完整性
        return pText[position];
    }
    char& operator[](std::siez_t position)
    { 
        ...         //边界检验
        ...         //日志数据访问
        ...         //检验数据完整性
        return pText[position];
    }
private:
    char* pText;
};

你能说出其中发生的代码重复以及伴随的编译时间、维护、代码膨胀等令人头疼的问题吗？你真正应该做的是operator[]的机能一次并使用它两次。也就是说，你必须令其中一个调用另一个。这促使我们将常量性转除。

令non-const operator[]调用其cosnt兄弟是一个避免代码重复的安全做法——即使过程中需要一个转型动作。

class TextBlock{
public:
    ...
    const char& operator[](std::siez_t position) const  //不变
    { 
        ...
        ...
        ...
        return pText[position];
    }
    char& operator[](std::siez_t position)              //现在只调用const op[]
    { 
        return const_cast<char &>(                      //将op返回值的const转除
            static_cast<const TextBlock&>(*this)        //为*this加上const
                [position]                              //调用const op[]
        );
    }
private:
    char* pText;
};

这里共有两次转型：第一次用来为*this添加const，第二次是从coant operator[]的返回值中移除const。
添加const的那一次转型强迫进行了一次安全转型（将non-const对象转为const对象），所以我们使用static_cast。移除const的那个动作只可以使用const_cast完成。

虽然这个代码看起来不怎么美观，但是实现了“避免代码重复”的效果，为了达到这个目标而写出如此难看的语法是否值得，只有你自己决定，但“运用const成员函数实现出其non-const孪生兄弟”的技术是值得了解的。更值得了解的是，反向做法——令const版本调用non-const版本,这是一个错误行为。