C/C++编程：尽可能的使用const

迈不过友情╰ 2023-01-19 03:10 154阅读 0赞

*  const的作用：指定一个语义约束（即指定一个**不应该被改动**的对象），而编译器会强制实施这项约素
 *  const使用场景：
    
     *  可以在类外修饰**全局**或者**命名空间**作用域中的常量
     *  可以修饰文件、函数、块作用域中被声明为`static`的对象
     *  可以在类内修饰**静态**或者**非静态**的成员变量
     *  可以修饰指针，用来指出指针自身、指针所指物、或者两者都（或者都不）是常量

char greeting[] = "Hello";
    char *p greeting;                // 指针、数据都可变
    const char * p = greeting;       // 指针可变，数据是常量
    char const * p = greeting;       // 指针可变，数据是常量
    char * const p = greeting;       // 数据可变，指针是常量
    const char * const p = greeting; // 指针、数据不可变

# const与迭代器 #

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

*  声明迭代器为const，表示这个迭代器不得指向不同的东西，但是它所指的值是可以改动的
 *  如果你希望迭代器所指的东西不可改动，需要使用`const_iterator`

#include <vector>
    
    int main(int argc, char* argv[])
    {
        
        std::vector<int> vec = {
        1, 2};
        
        const std::vector<int>::iterator iter = vec.begin();
        *iter = 10; 
       // ++iter;     // error: iter 是const
        
        std::vector<int>::const_iterator cIter = vec.begin();
        ++cIter;      // ok
       // *cIter = 10;  // error：*citer是const
        
        return 0;
    }

# const与成员函数 #

在一个函数声明式内，const可以和函数返回值、各参数、函数自身(如果是成员函数)产生关联

*  之所以有const成员函数，是为了确认该成员函数可以作用域const对象身上

#include <string>
    #include <cstring>
    #include <iostream>
    
    class TextBlock{
        
    public:
        TextBlock(std::string text){
        
            text = text;
        }
        const char * operator[](std::size_t position) const {
         //  operator[] for const object
            printf("const\n");
            return reinterpret_cast<const char *>(text[position]);
        }
        char& operator[](std::size_t position){
          //  operator[] for no-const object
            printf("noconst\n");
            return text[position];
        }
    
    private:
        std::string text;
    };
    
    int main(int argc, char* argv[])
    {
        
        TextBlock tb("Hello");   //  operator[] for no-const object
        tb[0] = 'x';               // ok
    
        const TextBlock ctb("Hello");  // //  operator[] for const object
       // ctb[0] = 'x';               // error
        return 0;
    }

成员函数如果是const意味着什么？这里有两个概念：`bitwise constness`(又称`physical constness`)和`logical constness`

## `bitwise constness` ##

bitwise constness主张：

*  成员函数只有在不更改对象的任何成员变量(static)除外才可以说是const。也就是说它不更改对象内的任何一个bit。
 *  这种论点的好处是很容易侦测违反点：编译器只需要寻找成员变量的赋值动作即可。
 *  bitwise constness正是C++对常量性(constness)的定义，因此**const成员函数不可以更改对象内任何非静态成员变量**。

不幸的是很多成员函数虽然不具备const性质但能通过bitwise测试。更具体的说，**一个更改了指针所指物的成员函数虽然不能算const，但如果只有指针(而非其所指物)隶属于对象，那么称此函数为bitwise const不会引发编译器异议**。这导致反直观结果。假设我们有一个TextBlock-like类，它将数据存储为char \*而不是string，因为它需要和一个不认识的string对象的C API沟通：

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

这个类不适当的将其operator\[\]声明为const成员函数，而该函数却返回一个引用指向对象内部值。假设暂时不管这个事实，请注意，`operator[]`实现代码并不更改pText。于是编译器很高兴的为`operator[]`产出目标吗。它是bitwise const，所有编译器都这么认定。但是看看它允许发生什么事：

const CTextBlock cctb("Hello"); //声明一个常量对象
    char *pc = &cctb[0];            //调用const operator[]取得一个指针，指向cctb的数据
    *pc = 'j';             // 通过

这与预期不符。

从而导入了`logical constness`

## `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); //error， 这是一个const成员函数
           // lengthIsValid = true;            //error， 这是一个const成员函数
        }
        return textLength;
    }

length的实现当然不是bitwise const，因为textLength和lengthIsValid都可能被修改。该怎么解决呢？----- 方法是使用C++的另一个关键字**mutable释放掉非静态成员变量的bitwise constness约束**：

class CTextBlock{
        
    public:
        std::size_t length() const ;
    private:
        char *pText;
        mutable std::size_t  textLength;
        mutable bool lengthIsValid;
    };
    
    
    std::size_t CTextBlock::length() const {
        
        if (!lengthIsValid){
        
            textLength = std::strlen(pText); //error
            lengthIsValid = true;            //error
        }
        return textLength;
    }

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

对于`bitwise-constness非我所欲`的问题，mutale是个解决方法。但它不能解决所有的const相关难题。

举个例子：假设TextBlock内的operator\[\]补单只是返回一个引用指向某字符，也执行边界检查、志记访问信息、数据完整性检验。把这些同时放进const和non-const operator\[\]中：

class CTextBlock{
        
    public:
        const char & operator[](std::size_t position) const {
        
        	// ... 执行边界检查、志记访问信息、数据完整性检验
            return text[position];
        }
        char & operator[](std::size_t position)  {
        
           // ... 执行边界检查、志记访问信息、数据完整性检验
            return text[position];
        }
    private:
        std::string text;
    };

这样的写法会有很多问题：代码重复、编译时间、维护等。 你可能会将边界访问…等代码转移到另一个（private）成员函数并让两个版本的operator\[\]调用它，但还是重复了一些代码，比如函数调用，两次return语句等。

你真正应该做的是实现operator\[\]的功能一次并使用它两次。也就是说，你必须令其中一个调用另一个。这促使我们将常量性转移。

就一般守则而言，转型是一个糟糕的想法。但是这里的const operator\[\]完全做了non-const版本应该做的一切，唯一的不同是其返回类型多了一个const资格修饰。这种情况下如果将返回值的const移除是安全的，因为不管是谁调用no-const operator\[\]都一定首先有个non-const对象，否则就不能调用no-const函数。所以令non-const operator\[\]调用其const函数是一个避免代码重复的安全做法—即使过程中需要一个转型操作：

class CTextBlock{
        
    public:
        const char & operator[](std::size_t position) const {
        
            return text[position];
        }
        char & operator[](std::size_t position)  {
        
            return const_cast<char &>(                          // 将op[]返回值的const移除
                    static_cast<const CTextBlock&>(*this)       // 为*this加上const
                    [position]									// 调用const op[]
                    );
        }
    private:
        std::string text;
    };

上面代码有两个转型操作：

*  第一次为\*this添加const（这里将`*this`从原始类型CTextBlock&转型为const CTextBlock&），这使得接下来调用operator\[\]时得以调用const版本
 *  第二次从const operator\[\]的返回值移除const

添加const的那一次转型强迫进行了一次安全转型(将non-const对象转为const对象)，所以需要用static\_cast。第二次转型需要移除const，所以需要用到const\_cast。

注意：

*  **不要**令const版本调用non-const版本以避免代码重复：const成员函数承诺绝不改变其对象，non-const成员函数却没有这样的承诺。如果在const函数内调用了non-const函数，就是冒了这样的风险：你曾经承诺不改动的那个对象改动了。
 *  令non-const版本调用const版本才是安全的：non-cosnt成员函数本来就可以对其对象做任何动作，所以在其中调用一个const成员函数并不会带来风险

# 总结 #

*  将某些东西声明为const可以帮助编译器侦测出错误用法。const可以被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体
 *  编译器强制实施bitwise constness，但你编写程序时应该使用概念上的常量性
 *  当const与non-cosnt成员函数有实质等级的实现时，令non-const版本调用const版本可以避免代码重复