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

晨曦之光 发布于 2012/05/23 11:01
阅读 523
收藏 1

原文: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


原文链接:http://blog.csdn.net/breakerzy/article/details/7291281
加载中
返回顶部
顶部