Effective C++----3rd Edition, Item 2:用consts,enums和inlines取代#define

转载 2016年05月10日 21:25:48

Item 2: 用 consts, enums 和 inlines 取代 #defines

作者:Scott Meyers

译者:fatalerror99 (iTePub's Nirvana)

发布:http://blog.csdn.net/fatalerror99/

这个 Item 改名为“用 compiler(编译器)取代 preprocessor(预处理器)”也许更好一些因为 #define 根本就没有被看作是语言本身的一部分。这是它很多问题中的一个。当你像下面这样做:

#define ASPECT_RATIO 1.653


compiler(编译器)也许根本就没有看见这个符号名 ASPECT_RATIO,在 compiler(编译器)得到源代码之前,这个名字就已经被 preprocessor(预处理器)消除了。结果,名字 ASPECT_RATIO 可能就没有被加入 symbol table(符号表)。如果在编译的时候,发现一个 constant(常量)使用的错误,你可能会陷入混乱之中,因为错误信息中很可能用 1.653 取代了 ASPECT_RATIO。如果,ASPECT_RATIO 不是你写的,而是在头文件中定义的,你可能会对 1.653 的出处毫无头绪,你还会为了跟踪它而浪费时间。在 symbolic debugger(符号调试器)中也会遇到同样的问题,同样是因为这个名字可能并没有被加入 symbol table(符号表)。


解决方案是用 constant(常量)来取代 macro(宏):

const double AspectRatio = 1.653;   // uppercase names are usually for
                                    // macros, hence the name change

作为一个 language constant(语言层面上的常量)AspectRatio 被 compilers(编译器)明确识别并确实加入 symbol table(符号表)另外,对于 floating point constant(浮点常量)(比如本例)来说,使用 constant(常量)比使用 #define 能产生更小的代码。这是因为 preprocessor(预处理器)盲目地用 1.653 置换 macro name(宏名字)ASPECT_RATIO,导致你的 object code(目标代码)中存在多个 1.653 的拷贝,如果使用 constant(常量)AspectRatio,就绝不会产生多于一个的拷贝。(对于其他类型呢?是不是也有相同的属性?我想应该是的。


用 constant(常量)代替 #defines 时,有两个特殊情况值得提出。首先是关于 constant pointers(常量指针)的定义。因为 constant definitions(常量定义)通常被放在 header files(头文件)中(这样它们就可以被包含在多个 source files(源文件)中),除了 pointer(指针)指向的目标是常量外,pointer(指针)本身被声明为 const 更加重要。例如,在头文件中定义一个 constant char*-based string(基于 char* 的字符串常量)时,你必须写两次 const:

const char * const authorName = "Scott Meyers";

对于 const(特别是与 pointers(指针)相结合时)的意义和使用的完整讨论,请参见 Item 3。然而在此值的一提的是,string objects(对象)通常比它的 char*-based(基于 char*)的祖先更可取,所以,更好的 authorName 的定义方式如下:
const std::string authorName("Scott Meyers");

第二个特殊情况涉及到 class-specific constants(类属(类内部专用的)常量)。为了将一个 constant(常量)的作用范围限制在一个 class(类)内,你必须将它作为一个类的 member(成员),而且为了确保它最多只有一个 constant(常量)拷贝,你还必须把它声明为一个 static member(静态成员)

class GamePlayer {
private:
  static const int NumTurns = 5;      // constant declaration
  int scores[NumTurns];               // use of constant
  ...
};

然而你所看到的是NumTurns的声明形式而非定义性史。通常,C++ 要求你为你使用的任何东西都提供一个 definition(定义),但是一个 static(静态)的 integral type(整型族)(例如:integers(整型),chars,bools)的 class-specific constants(类属常量)是一个例外。(三个条件同时满足)。只要你不去取得它们的 address(地址),(也就是说,只声明不定义,无法取得地址)你可以只声明并使用它,而不提供它的 definition(定义)。如果你要取得一个 class constant(类属常量)的 address(地址),或纵使你不取其地址而你的编译器却(不正确地)坚持要看到一个定义式,你可以提供如下这样一个独立的 definition(定义):
const int GamePlayer::NumTurns;     // definition of NumTurns; see
                                    // below for why no value is given


你应该把它放在一个 implementation file(实现文件)而非 header file(头文件)中。因为 class constants(类属常量)的 initial value(初始值)在声明时已经提供(例如:NumTurns 在定义时被初始化为 5),因此在定义处允许没有 initial value(初始值)。


注意,顺便提一下,没有办法使用 #define 来创建一个 class-specific constant(类属常量),因为 #defines 不考虑 scope(作用范围)。一旦一个 macro(宏)被定义,它将大范围影响你的代码(除非在后面某处存在 #undef)。这就意味着,#defines 不仅不能用于 class-specific constants(类属常量),而且不能提供任何形式的 encapsulation(封装),也就是说,没有类似 "private"(私有)(相当于局部变量吧。。。)#define 的东西。当然,const data members(const 数据成员)是能够被封装的,NumTurns 就是如此。


比较老的 compilers(编译器)可能不接受上面的语法,因为它习惯于将一个 static class member(静态类成员)在声明时就获得 initial value(初始值)视为非法。而且,in-class initialization (类内初始化)仅仅对于 integral types(整型族)和 constants(常量)才被允许。如果上述语法不能使用,你可以将 initial value(初始值)放在定义处:

class CostEstimate {
private:
  static const double FudgeFactor;   // declaration of static class
  ...                                // constant;位于头文件内
};
const double                         // definition of static class
  CostEstimate::FudgeFactor = 1.35;  // constant; goes in impl. file

这就是你所要做的全部。仅有的例外是当在类的编译期需要 value of a class constant(一个类属常量的值)的情况,例如前面在声明 array(数组)GamePlayer::scores 时(compilers(编译器)必须在编译期知道 array(数组)的 size(大小))。如果 compilers(编译器)(不正确地)禁止这种关于 static integral class constants(静态整型族类属常量)的 initial values(初始值)的使用方法的 in-class specification(规范),一个可接受的替代方案被亲切地(并非轻蔑地)昵称为 "the enum hack"。这项技术获得以下事实的支持:一个 enumerated type(枚举类型)的值可以用在一个需要 ints 的地方。所以 GamePlayer 可以被如下定义:(也就是是说,老版本的编译器如果不支持static const整数类型的初始化的话,那么就无法使用其值,这时候应该用枚举类型)

class GamePlayer {
private:
  enum { NumTurns = 5 };             // "the enum hack" - makes
                                     // NumTurns a symbolic name for 5
  int scores[NumTurns];              // fine
  ...
};

the enum hack 有几个值得被人所知的原因。首先,the enum hack 的行为在几个方面上更像一个 #define 而不是 const,而有时这正是你所需要的(无法取得地址)。例如:可以合法地取得一个 const 的 address(地址),但不能合法地取得一个 enum 的 address(地址),这正像同样不能合法地取得一个 #define 的 address(地址)。如果你不希望人们得到你的 integral constants(整型族常量)的 pointer(指针)或 reference(引用),enum(枚举)就是强制约束这一点的好方法。(关于更多的通过编码的方法强制执行设计约束的方法,参见 Item 18。)同样,使用好的 compilers(编译器)不会为 integral types(整型族类型)的 const objects(const 对象)分配多余的内存(除非你创建了这个对象的指针或引用),即使拖泥带水的 compilers(编译器)乐意,你也决不会乐意为这样的 objects(对象)分配多余的内存。像 #defines 和 enums(枚举)就绝不会导致这种 unnecessary memory allocation(不必要的内存分配)。


需要知道 the enum hack 的第二个理由是纯粹实用主义的,大量的代码在使用它,所以当你看到它时,你要认识它。实际上,the enum hack 是 template metaprogramming(模板元编程)的一项基本技术(参见 Item 48)。


回到 preprocessor(预处理器)上来,#define 指令的另一个普遍的(不好的)用法是实现看来像函数,但不会招致函数调用(function call)带来的额外开销。以下是一个用较大的宏参数调用函数 f 的 macro(宏):

// call f with the maximum of a and b
#define CALL_WITH_MAX(a, b) f((a) > (b) ? (a) : (b))


这样的 macro(宏)有数不清的缺点,想起来就让人头疼。


无论何时,你写这样一个 macro(宏),都必须记住为 macro body(宏体)中所有的 arguments(参数)加上括号。否则,当其他人在表达式中调用了你的 macro(宏),你将陷入麻烦。但是,即使你确实做到了这一点,你还是会看到意想不到的事情发生:

int a = 5, b = 0;
CALL_WITH_MAX(++a, b); // a is incremented twice
CALL_WITH_MAX(++a, b+10); // a is incremented once


这里,调用 f 之前 a 递增的次数取决于它和什么进行比较!


幸运的是,你并不是必须要和这样不知所云的东西打交道。你可以通过一个 inline function(内联函数)的 template(模板)来获得 macro(宏)的效率,以及完全可预测的行为和常规函数的类型安全(参见 Item 30):

template<typename T>                               // because we don't
inline void callWithMax(const T& a, const T& b)    // know what T is, we
{                                                  // pass by reference-to-
  f(a > b ? a : b);                                // const - see Item 20
}


这个 template(模板)产生一组函数,每一个获得两个相同类型的对象并使用其中较大的一个调用 f。这样就不需要为函数体内部的参数加上括号,也不需要担心多余的参数解析次数,等等。此外,因为 callWithMax 是一个真正的函数,它遵循函数的作用范围和访问规则。例如,谈论一个类的私有的 inline function(内联函数)会获得正确的理解,但是用 macro(宏)就无法做到这一点。


为了得到 consts,enums 和 inlines 的可用性,你需要尽量减少preprocessor(预处理器)(特别是 #define)的使用,但还不能完全消除。#include 依然是基本要素,而 #ifdef/#ifndef 也继续扮演着重要的角色。现在还不是让 preprocessor(预处理器)完全退休的时间,但你应该给它漫长而频繁的假期。

Things to Remember


  • 对于 simple constants(简单常量),用 const objects(const 对象)或 enums(枚举)取代 #defines。
  • 对于 function-like macros(类似函数的宏),用 inline functions(内联函数)取代 #defines。



总结:

  • #define定义的常量在使用时会产生多个拷贝,而用const定义的常量不会出现多于一个的拷贝
  • #define不能定义在局部变量中,比如类的成员变量不能定义为#define
  • static & 类属常量 & 整型类型 只是声明了该变量(可以有初始值),而没有对该变量进行定义,定义应该放在源文件中,如果声明了初始值,定义时可以不用初始值
  • 类内初始值(老编译器)仅限于整型类型和常量类型初始化
  • 类内常量用const或者enumeration代替#define

Effective C++ (3rd Ed) 读书笔记(一)Item 2: Prefer constS, enumS, and inlineS to #defineS

#includecxvxv

effective C++ Item 2: Prefer consts, enums, and inlines to #defines

前面一款基本上就是介绍性的内容,这一节进入主题。   条款二:尽量以const,enum,inline代替#define   1:使用const代替#define定义常量。     如果你定义圆...

Effective C++----3rd Edition, Item 3:尽可能使用const

Item 3: 只要可能就用 const 作者:Scott Meyers 译者:fatalerror99 (iTePub's Nirvana) 发布:http://blog.csdn...

《Effctive C++》读书笔记--(02)Prefer consts,enums,and inlines to #defines

宁可以编译器替换预处理器。 宏的缺点: 由于#define宏定义由预处理器管理,通常可以理解为宏即为替换,例: #define LENSIZE 20     在预处理时,编译器会将代码中的所有...

Effective C++,rule 2,Prefer const,enum and inlines to #define

前言rule2主要讲的是#define相关的一些东西,由标题可知,这里说的是#define的在某些方面的不足以及一些可行的建议。另外,本节一个重要的内容就是enum hack技术。enum hack ...
  • jmh1996
  • jmh1996
  • 2017年04月27日 01:07
  • 196

【Effective C++ 3rd 心得、归纳、实践】 Item 12: 拷贝一个对象的所有组成部分

本文主要对派生类的拷贝构造函数通过代码进行各种试验 主要几个关注点: 1.自定义的拷贝构造函数中未初始化的成员,编译器会隐式帮助初始化吗 2.派生类的拷贝构造函数在不指定基类构造...

Effective C++学记之02 使用const enums inline来代替#define

条款02 对于单纯常量,最好以const对象或enum替换#define;对于形似函数的宏,最好改用inline函数替换#define。 1首先了解一下预处理和编译的区别: 编译程序对源代码进行编...

重读经典-《Effective C++》Item2:尽量以const,enum,inline替换#define

本博客(http://blog.csdn.net/livelylittlefish )贴出作者(三二一@小鱼)相关研究、学习内容所做的笔记,欢迎广大朋友指正!   1. 宏定义   ...

Effective C++ 3rd Item 9

  • 2009年04月04日 03:13
  • 34KB
  • 下载

Unix Network Programming Volume 1 Compile issue solution for the 2nd and 3rd edition

Unix Network ProgrammingVolume 1: The Sockets Networking API.Compile issue solution for the 2nd and ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Effective C++----3rd Edition, Item 2:用consts,enums和inlines取代#define
举报原因:
原因补充:

(最多只允许输入30个字)