C++ 惯用法: const 常量和字面量

原文：C++ 惯用法: const 常量和字面量
作者：Breaker <breaker.zy_AT_gmail>

---

C++ 中 const 关键字、常量和字面量的惯用法

关键字：const, enum, const_cast, const_iterator, mutable, 左值, 字面量

本质和非本质上的常量

字面量 (literal)，是指在 C++ 中直接书写的数字、字符和字符串，如 0x3f, '+', 1.23e-15L, "hello", L"world"，具体语法参考 [CPP_LANG] 4.3.1 字符 4.4.1 整数 4.5.1 浮点数 5.2.2 字符串

左值 (l-value)，是指想尽办法可以让其放到 = 左面的对象，这里的 = 是赋值而不是初始化，这里的对象可以是类类型和基本类型。想尽办法主要指强制转换和指针地址操作

本质上的常量，指非左值，字面量、enum 枚举值是非左值

字面量的 const 变量

是否能通过强制而修改，由编译优化和运行平台决定，这是 Win7 VC 2010 的情况：

通过 const_cast 修改字面量的 const 变量 字面量的 const 变量 是否能修改

static 数字字面量 const	不可修改
non-static local 数字字面量 const	可修改
non-static local const char[]	可修改
static const char[]	不可修改
const char* 字符串字面量	不可修改

这些通过强制而修改字面量 const 变量的代码很难移植，并且不是正常的逻辑，所以认为字面量 const 变量是本质上的常量是合理的

const T& 引用

参考 [CPP_LANG] 5.5 引用

和字面量的 const 变量不同，字面量的 const T& 会引用一个临时变量

const int& g_C = 42;

// 解释为:
// int temp = 42;
// const int& g_C = temp;

// 所以强制是合理的
const_cast<int&>(g_C) = 43;

类类型也是如此，并且 const T& 的初始值可以不是类型 T 的，会自动隐式转换，而这一点对于 non-const T& 不成立的，如：

// std::basic_string 中有 const char_type* 的转换 ctor
void func_1(std::string& str);
void func_2(const std::string& str);

void test() {
    func_1("hello");    // Error, string& 不能接受 const char[]
    func_2("hello");    // OK, const string& 自动隐式转换
}

非本质的常量

非本质的常量比本质的常量更容易理解和确定，通常是函数的 const 参数接受的 non-const 初始化，如：

char* strcpy(char* dest, const char* src);
class Widget {
public:
    void show() const;
};

void func() {
    char str[] = "hello world";
    char str2[64];
    strcpy(str2, str);  // strcpy 中 src 是非本质的 const

    Widget w;
    w.show();           // Widget::show 中 this 是非本质的 const*
}

非本质的常量的目的，是在一定执行区间内约束代码（不保证区间外是否 const），产生试图修改 const 的编译错误

常量求值

本质上的常量，可以在编译期求值，它们或化为指令立即数，或保存在目标文件 (.obj) 和可执行文件 (.exe/.dll) 的特殊位置，如 .rdata 区段

也因在编译期求值，本质上的常量可以作为非类型模板参数，只需注意指针类型模板参数只接受外部链接对象的地址，而字符串字面量是内部链接的，这时用外部链接的字符数组代替即可

非本质的常量，在运行时求值

有一些在运行时求值的非平凡情况，评估它们的常量本质性：

// strdup 早于 main 调用
const char* g_Str = strdup("hello");

// Widget ctor 早于 main 调用
const Widget g_Widget;

void func() {
    const_cast<char*>(g_Str)[0] = 'A';
    free(const_cast<char*>(g_Str));

    const_cast<Widget&>(g_Widget).move(); // 设 Widget::move 是 non-const 方法
}

常量存储

左值一定分配存储，因此可以取其地址

本质的常量（非左值）不一定分配存储，是否分配由具体情况、编译优化和运行平台决定，参考 [CPP_LANG] 5.4 常量

• enum 不分配存储

• 字面量的 const 变量，如果不引用其地址，如创建指向它的指针或引用，则也不需要分配存储，但具体视编译优化而定

• 类的 static 整数 const，如果不引用其地址，则可以只用声明式而不用定义式，此时不需要分配存储；如果引用其地址，则需要定义式，并且分配存储

  class Widget {
      static const int Num = 5;
  };
  const int Widget::Num;  // 引用 Num 地址时，需要定义式
  

const 对比 volatile

const 关键字的横向对比物是 volatile，对比两者可以更明白本质

• 和编译优化相关

  volatile 是防止变量访问被激进优化的修饰字，volatile 变量的每次读写都会产生实际的内存访问指令，以防止因编译期不可知的因素（如并发线程的共享变量访问）而优化去除 volatile 变量的内存访问（如访问寄存器中的旧值）

  本质 const 可能被优化存储，如存储到 ROM 中

  优化一定和具体编译器与平台有关，这里 C++ 是定义一种适当的目的描述，而非实现细节，如 VC 2005+ 的 volatile 变量读写带有 Acquire/Release 语义以防止编译期指令 reorder，但仅在 IA64 上保证相同的运行时模型，x86 x64 上仍允许运行时 CPU reorder

  本质 const 的存储也是平台相关的，所以上面表格中的 const_cast 很难移植

• 非本质的 const 和 volatile

  非本质的 volatile 此称谓并不适当，权作和 const 对比，通常是函数的 volatile 参数接受的 non-volatile 初始化，如 InterlockedExchange(volatile LONG*, LONG) 中，它的目的和 const 参数相似，是在一定执行区间内约束代码（不保证区间外是否 volatile），防止那里的激进优化

• 用 const_cast 强制去除 const, volatile 修饰字

  const_cast 只能去除非本质 const 的 const 修饰

• 指向 const/volatile 的指针和 const/volatile 指针，参考 MSDN: const and volatile Pointers

  const T*        pc; // 指针引用物是 const
  T* const        cp; // 指针值是 const
  volatile T*     vp; // 指针引用物是 volatile
  T* volatile     pv; // 指针值是 volatile
  

const_iterator

一些 STL 容器如 vector 有 iterator 和 const_iterator 两种迭代器

vector<T>::const_iterator 是 const T*
const vector<T>::iterator 是 T* const

const 和 non-const 方法

class Widget {
public:
    void move(int x, int y);    // non-const 方法
    // 解释为:
    // void move(Widget* this, int x, int y);

    void show() const;          // const 方法
    // 解释为:
    // void show(const Widget* this);
};

void func() {
    const Widget cw;
    Widget w;

    w.move(42, 84);     // OK, non-const 对象调用 non-const 方法
    w.show();           // OK, non-const 对象调用 const 方法
    cw.move(42, 84);    // Error, const 对象调用 non-const 方法
    cw.show();          // OK, const 对象调用 const 方法
};

逻辑上的 const 方法

参考 [CPP_LANG] 10.2.7.1, 10.2.7.2 mutable

有时我们需要在 const 方法里修改对象的状态（成员变量），这时需要用 mutable 修饰那个被修改的成员变量

典型的惯用法：返回对象状态时，先检查其 cache 值，如果需要更新，则修改其值，如：

class Widget {
public:
    // 这里的计算太简单，cache 效率可能比无 cache 差，仅作示例
    // 合理的场景是有复杂计算过程的方法
    int area() const {
        if (m_size_changed) {
            m_area = m_height * m_width;
            m_size_changed = false;
        }
        return m_area;
    }
    void move(int x, int y, int dx, int dy);    // 设置 m_size_changed = true

private:
    int         m_height;
    int         m_width;
    bool        m_size_changed;
    mutable int m_area;
};

从 Widget 用户的角度看，Widget::area() 是具有 const 逻辑的

方法的 const 和 non-const 版本

一些 STL 容器如 vector 有同一个 operator 的 const 和 non-const 两个版本，如 vector<T> 实例化后有两个 operator[]：

class vector<T> {
    T& operator[](size_type p);
    const T& operator[](size_type p) const;
};

第一个 operator[] 可用来充当左值（准确的说是可变左值 modifiable l-value），因为所有的左值都是右值，所有它也可充当右值（注意 右值和非左值的区别）

那第二个版本 const 版本的 operator[] 岂不是多余

其实它和非本质 const 配合，用来约束代码，逻辑很合理：如果 vector<T> 是 const，那么每个元素都应该是 const，反之，假如元素能修改，就称不上是 const vector<T>，如：

void print(const vector<T>& vec) {
    for (vector<T>::size_type i = 0; i < vec.size(); i++)
        cout << vec[i] << '\n';   // 作用 1: 调用第二个版本的 operator[], 因为 vec 是 const* this
    vec[0] = T(42);               // 作用 2: 不小心写错, 但 vec[0] 是 const T&, 编译出错从而保护
}

分清两个位置 const 的作用：

作用 1, 返回值 const T&: 产生约束保护
作用 2, const 方法 (const* this): 产生重载规则，C++ 不能仅通过返回不同类型重载函数

也可以理解为，同一方法概念的两个版本：

non-const 版: set 式方法
const 版: get 式方法

转接 non-const 方法到 const 方法

虽然区分同一方法概念的两个版本，但大多数时候，const 和 non-const 版本的内部操作相同，仅在传入参数和返回值类型上不同

为了简化重复代码，可利用 static_cast/const_cast 将 non-const 方法转接到 const 方法，如 vector<T> 的 non-const operator 可如下转接：

T& vector<T>::operator[](size_type p) {
    return const_cast<T&>(                           // 转换 const T& 到 T&，因为事先知道 this 是非本质的 const*，所以强制是安全的
        static_cast<const vector<T>&>(*this)[p]);    // 转换 non-const* this 到 const* this，从而调用 const operator
}

反向的，将 const 转接到 non-const 上会违背 const 承诺，不要那么做

参考

[CPP_LANG] 《C++ 程序设计语言》特别版, Bjarne Stroustrup

[EFF_CPP] "Effective C++", 3Ed, Scott Meyers, 条款 02, 03