《Effective C++》读书笔记之尽量以const，enum，inline替换#define

const和enum替代#define

当我们以常量const替换#define的时候，有两种特殊情况需要特别注意：

• 定义常量指针
  由于常量定义式通常被放在头文件中，以便被不同的源码含入，因此有必要将指针声明为const，而不只是指针所指之物，否则多个源文件包含同一个头文件时，会对其中的变量定义多次，从而出现多次定义的错误。
  比如：
  其中的头文件"test.h"如下

#ifndef TEST_H_
#define TEST_H_
#include "stdio.h"
const char* const authorName = "Scott";
void func();
#endif

第一个包含此头文件的源文件“test1.cpp”

#include <iostream>
#include "test.h"
using namespace std;

int main()
{
	cout << "main: "<< authorName << endl;
	func();
}

第二个包含此头文件的源文件“test2.cpp”

#include "test.h"
using namespace std;

void func()
{
	cout << "func: "<< authorName << endl;
}

可以看出程序能正常运行。

若取消掉指针的const属性，就会出现重复定义的问题。

• class专属常量
  为了将常量的作用域限制于class内，你必须让它成为class的一个成员，而且为了确保此常量至多只有一份实体，你必须让它成为一个static成员：

class GamePlayer
{
private:
	static const int NumTurns = 5;//常量声明式
	int scores[NumTurns];         //使用该常量
	...
};

需要注意的是这里的Numturns是声明式而非定义式。
通常C++要求你对你所使用的任何东西提供一个定义式，但如果它是个class专属常量又是static且为整数类型，则需特殊处理。只要不取它们的地址，你可以声明并使用它们而无须提供定义式。但如果你取某个class专属常量的地址，或纵使你不取其地址而你的编译器却（不正确地）坚持要看到一个定义式，你就必须另外提供定义式如下：

const int GamePlayer::Numturns;

由于class常量已在声明时获得初值，因此定义时不可以再设初值。
有些旧编译器也许不支持上述语法，它们不允许static成员在其声明式上获得初值。此外所谓的“类内初值设定”也只允许对整数常量进行。如果你的编译器不支持上述语法，你可以将初值放在定义式：

class CostEstimate
{
	static const double FudgeFactor;    //static class 常量声明
	...                                 //位于头文件中
};
const double CostEstimate::FudgeFactor=1.35;   //static class 常量定义
                                               //位于实现文件中

• Q: 关于为什么static成员一定要在类外初始化？
• A: 因为被static声明的类静态数据成员，其实体远在main函数开始之前就已经在全局数据段产生了，其生命期和类的对象是异步的，静态语意说明即使没有类实体的存在，其静态数据成员的实体也是存在的，这个时候对象的生命期还没有开始，如果你要到类中去初始化类静态数据成员，让静态数据成员的初始化依赖于类的实体，那怎么满足前述的静态语意呢？如果类一直不实例化，就永远不能访问到被初始化的静态数据成员吗？

现在又有一个问题，如果当你在class编译期间需要一个class常量值，例如上述的GamePlayer::scores的数组声明式中。这时候万一你的编译器恰好不允许“static整数型class常量”完成“类内初值设定”，可改用所谓的“the enum hack”补偿做法。其理论基础是：一个属于枚举类型的数值可权充int被使用，于是GamePlayer可定义如下：

class GamePlayer
{
	enum{NumTurns=5};
	int scores[NumTurns];
	...
};

inline替换#define

用#define来实现宏，有时也会出错。比如：

#define CALL_WITH_MAX(a,b) f((a)>(b)?(a):(b))

虽然上述这个宏看起来像函数，但不会招致函数调用带来的额外开销。需要注意的是，无论何时你写出这样的宏，都必须为宏中的所有实参加上小括号，否则某些人在表达式中调用这个宏时可能出现问题，但纵使你为所有实参加上小括号，有时还是会出错。 请看下面这个案例：

int a = 5, b = 0;
CALL_WITH_MAX(++a,b);
CALL_WITH_MAX(++a,b+10);

第一个CALL_WITH_MAX中的a被调用两次，首先完成一次自加，然后和b比较后发现比b大，故又完成一次自加；而第二个由于a自加后比b小，故返回b，因为a只自加一次。
为了可以同时获得宏带来的效率以及一般函数的所有可预料行为和类型安全性，我们考虑模板inline函数：

template<typename T>
inline void callwithmax(const T& a, const T& b)
{
	f((a)>(b)?(a):(b));
}

这里不需要在函数本体中为参数加上括号，也不需要操心参数被核算求值多次等等。此外由于callwithmax是个真正的函数，它遵守作用域和访问规则。例如你绝对可以写一个class内的private inline函数。一般而言宏无法完成此事。

记住：

• 对于单纯常量，最好以const对象或enums替换#define。
• 对于形似函数的宏，最好改用inline函数替换#define。

对于inline函数：

• C++关键字，在函数声明或定义中函数返回类型前加上关键字inline，即可以把函数指定为内联函数。关键字inline必须与函数定义放在一起才能使函数成为内联，仅仅将inline放在函数声明前面不起任何作用。inline是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。一般的，用户可以阅读函数的声明，但是看不到函数的定义。
• 运用inline函数的原因如下：
• 1．C中使用define这种形式宏定义的原因是因为，C语言是一个效率很高的语言，这种宏定义在形式及使用上像一个函数，但它使用预处理器实现，没有了参数压栈，代码生成等一系列的操作。因此，效率很高，这是它在C中被使用的一个主要原因。
• 2．这种宏定义在形式上类似于一个函数，但在使用它时，仅仅只是做预处理器符号表中的简单替换，因此它不能进行参数有效性的检测，也就不能享受C++编译器严格类型检查的好处，另外它的返回值也不能被强制转换为可转换的合适的类型。这样，它的使用就存在着一系列的隐患和局限性。
• 3．在C++中引入了类及类的访问控制，这样，如果一个操作或者说一个表达式涉及到类的保护成员或私有成员，你就不可能使用这种宏定义来实现（因为无法将this指针放在合适的位置）。
• 4．inline推出的目的，也正是为了取代这种表达式形式的宏定义，它消除了宏定义的缺点，同时又很好地继承了宏定义的优点。
  预定义
• 对应于上面的1-3点，阐述如下：
• 1．inline定义的类的内联函数，函数的代码被放入符号表中，在使用时直接进行替换（像宏一样展开），没有了调用的开销，效率也很高。
• 2．很明显，类的内联函数也是一个真正的函数，编译器在调用一个内联函数时，会首先检查它的参数的类型，保证调用正确。然后进行一系列的相关检查，就像对待任何一个真正的函数一样。这样就消除了它的隐患和局限性。
• 3．inline可以作为某个类的成员函数，当然就可以在其中使用所在类的保护成员及私有成员。
• 在何时使用inline函数：
• 1．首先，你可以使用inline函数完全取代表达式形式的宏定义。
• 2．另外要注意，内联函数一般只会用在函数内容非常简单的时候。这是因为，内联函数的代码会在任何调用它的地方展开，如果函数太复杂，代码膨胀带来的恶果很可能会大于效率的提高带来的益处。内联函数最重要的使用地方是用于类的存取函数。

第一次写博客，有不足之处，请多指教！