C/C++ 预处理与宏的高级用法

预处理（preprocessing）主要是文本替换的过程。

1. 将所有的#define删除，并且展开所有的宏定义。说白了就是字符替换
2. 处理所有的条件编译指令，#ifdef #ifndef #endif等，就是带#的那些
3. 处理#include，将#include指向的文件插入到该行处
4. 删除所有注释
5. 添加行号和文件标示，这样的在调试和编译出错的时候才知道是是哪个文件的哪一行
6. 保留#pragma编译器指令，因为编译器需要使用它们

1. #define的基本用法

#define PI 3.1415

预处理时会将所有出现的PI替换为3.1415

#define A 32+6
int i = 6*A;

预处理时会变成int i = 6*32 + 6;而不是6*38。

所以是纯文本替换，不会帮你把简单计算的结果计算出来。

2. 重复定义

如果我们定义一个vehicle.h，里面有vehicle类。
在car.h里定义car类继承自vehicle，并且#include "vehicle.h"
在car.cpp里如果将二者都引用

#include "vehicle.h"
#include "car.h"

就会出现重复定义的错误，因为vehicle.h会在嵌入到cpp上方时被嵌入两次。
解决方法有两种：
(1). 使用#ifdef #ifndef #endif

#ifndef VEHICLE_H
#define VEHICLE_H
class vehicle{...}
#endif

这样当嵌入两次的时候，第二次会先进入#ifndef VEHICLE_H，然后发现已经被定义了，就会直接跳到#endif后面。
(2). 使用#pragma once
在include后面跟上一行
#pragma once
编译器build的时候就会直接把重复的头文件去掉，比较简单省事，但你debug的时候编译器因为隐藏了一些头文件的嵌入，所以检查错误的时候不方便。

3. #define简单函数

#define MAX(a,b) a>b ? a : b

这样可以就定义了一个MAX函数，可以取两个参数中大的那个返回。
优点
无视类型，什么东西都能传进去，类似template。（这一点也有可能是坏处而不是优点）
缺点
如果出现如下代码：

int i = MAX(7*6, 2);

它被预处理后会变成

int i = 7*6 > 2 ? 7*6 : 2;

这样7*6会被计算2次，多了一次重复计算，降低了效率。

3. #define的高级花式用法

当我们想define多行代码段时怎么办？
使用“\”，将“\”附在行尾，即可在预处理时将多行合并成一行，既保持了可读性，又能够define成功。

#define CLASS_DECLARE(c)\
const char* GetName(){\
    return #c;}\ 
static int s_num;\
int attribute1;\
int attribute2

注意：#号会让传进去的参数c的类型变成一个string，即返回传进去的c的类型的string，比如我们调用CLASS_DECLARE(new Car())，它就会返回“Car”这么一个string，这样就得到了类型名称。

我们可以在多个类中重复使用CLASS_DECLARE()，这样每个类里都有了GetName()这个函数以及s_num, attribute1, attribute2三个成员变量。

但是当我们在多个类中使用 CLASS_DECLARE() 时，会出现link error，因为编译器不知道
s_num，attribute1，attribute2 属于哪个类，此时如果我们再宏定义一个代码段

#define CLASS_DEFINE(c)\
int c::s_num = 0;\
int c::attribute1 = 0;\
int c::attribute2 = 0

然后我们定义一个Car类

Car.h
============================
class Car
{
  CLASS_DECLARE(Car);
}

Car.cpp
============================
CLASS_DEFINE(Car);

这样就不会出现link error，而且Car里面有了GetName()这个函数以及s_num, attribute1, attribute2三个成员变量。

个人感觉这种用法可以复用代码段来对多个类进行初始化，很像C++里的父类继承。
但父类继承更容易理解也更容易写容易读，define出来的可读性比较差，而且debug的时候由于预处理文本替换的原因，你无法定位到define的那行代码上，不好调试。
唯一的优点大概就是执行效率会比父类继承快一点，可能游戏引擎这种比较要求高效率的代码中会用到。

PS:宏定义中#号的花式用法

1. if else 代码块

#define VAR 1
#if VAR == 1
//do something
#elif VAR == 2
//do something
#else 
//do something
#endif

2. “##”连接
   A ## B即返回AB这么一个字符串，会把##以及前后的空格都去掉。

#define HANDLER_WRAPPER(c) \
    static void c ## Wrapper(a) {return a;}

Class Car {
  HANDLER_WRAPPER(Car);//Car中拥有了CarWrapper()函数
}