C++ 宏定义 ## 令牌粘合运算符

令牌粘合运算符（##）简介

底层原理

使用示例

构建类型相关的函数

在 C++ 宏定义中，## 是一个预处理器运算符，称为令牌粘合运算符（token-pasting operator）。它用于将两个令牌拼接成一个新的标识符或令牌。

令牌粘合运算符（`##`）简介

在 C++ 中，令牌粘合运算符（##），也称为令牌拼接运算符或令牌连接运算符，是一种用于宏定义的预处理器运算符。它的主要功能是在宏展开过程中，将两个令牌拼接在一起形成一个新的单一标识符或令牌。这个运算符使得可以在宏中动态地构建标识符，从而生成更加灵活的代码结构。

底层原理

在预处理阶段，C++ 编译器处理源代码中的宏定义和宏调用。使用 ## 运算符时，预处理器将会执行以下操作：

宏展开：预处理器首先将宏定义中的参数替换为实际传递的值。
令牌粘合：如果宏定义中使用了 ## 运算符，预处理器会将 ## 两侧的令牌直接拼接成一个新的令牌。
代码替换：完成粘合后，新的令牌会被替换到代码中相应的位置。

这种操作仅在预处理阶段进行，不涉及编译和链接阶段，因此不会对程序的运行时性能产生直接影响。

使用示例

构建类型相关的函数

#include <iostream>

#define CREATE_PRINT_FUNC(type)                \
    void print_##type(type value) {            \
        std::cout << "Value: " << value << std::endl; \
    }

CREATE_PRINT_FUNC(int)
CREATE_PRINT_FUNC(float)
CREATE_PRINT_FUNC(char)

int main() {
    print_int(42);    // 调用 print_int，输出：Value: 42
    print_float(3.14f);  // 调用 print_float，输出：Value: 3.14
    print_char('A');  // 调用 print_char，输出：Value: A

    return 0;
}

解释：

CREATE_PRINT_FUNC(int) 展开后生成了一个名为 print_int 的函数，该函数接收一个 int 类型的参数并打印它。
CREATE_PRINT_FUNC(float) 和 CREATE_PRINT_FUNC(char) 类似，生成了 print_float 和 print_char 函数。

这种方法非常有用，可以避免编写重复代码，特别是在不同类型处理逻辑相似的场景中。

通过宏生成多个函数

在某些情况下，你可能需要为一系列不同类型的数据生成一组相似的函数。可以使用 ## 令牌粘合运算符来自动生成这些函数，而不必手动编写每个函数。

#include <iostream>
#include <string>

#define GENERATE_GETTER_SETTER(type, name)            \
    class Test##name {                                \
    private:                                          \
        type name##_;                                 \
    public:                                           \
        void set_##name(type value) {                 \
            name##_ = value;                          \
        }                                             \
        type get_##name() const {                     \
            return name##_;                           \
        }                                             \
    };                                                \
                                                      \
    void test_##name() {                              \
        Test##name obj;                               \
        obj.set_##name(static_cast<type>(10));        \
        std::cout << "The value of " #name ": "       \
                  << obj.get_##name() << std::endl;   \
    }

GENERATE_GETTER_SETTER(int, Age)
GENERATE_GETTER_SETTER(float, Salary)
GENERATE_GETTER_SETTER(std::string, Name)

int main() {
    test_Age();       // 测试生成的 int 类型 Age 的 getter 和 setter
    test_Salary();    // 测试生成的 float 类型 Salary 的 getter 和 setter
    test_Name();      // 测试生成的 std::string 类型 Name 的 getter 和 setter

    return 0;
}

解释：

GENERATE_GETTER_SETTER(int, Age) 生成了一个 TestAge 类，该类包含一个私有成员变量 int Age_ 以及其 getter 和 setter 方法。还生成了一个名为 test_Age 的函数，用于测试这个类。
该宏进一步利用了 ## 和 # 运算符的组合（其中 # 用于将参数转换为字符串），自动生成了与属性 name 相关的成员函数和测试代码。

创建多态工厂类

在面向对象编程中，工厂模式常被用来创建对象。可以使用 ## 运算符和宏生成不同类型对象的工厂方法。

#include <iostream>
#include <memory>
#include <string>

#define CREATE_FACTORY(BaseClass, DerivedClass)        \
    class DerivedClass##Factory : public BaseClass {   \
    public:                                            \
        std::unique_ptr<BaseClass> create() {          \
            return std::make_unique<DerivedClass>();   \
        }                                              \
    };

class Product {
public:
    virtual ~Product() = default;
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

CREATE_FACTORY(Product, ConcreteProductA)
CREATE_FACTORY(Product, ConcreteProductB)

int main() {
    ConcreteProductAFactory factoryA;
    ConcreteProductBFactory factoryB;

    auto productA = factoryA.create();
    auto productB = factoryB.create();

    productA->use();  // 输出 "Using ConcreteProductA"
    productB->use();  // 输出 "Using ConcreteProductB"

    return 0;
}

自动生成消息处理器

在网络通信或命令处理的系统中，经常需要处理不同类型的消息或命令。可以利用 ## 运算符自动生成这些消息处理函数。

#include <iostream>
#include <string>

#define HANDLE_MESSAGE(message)                      \
    void handle_##message(const std::string& msg) {  \
        std::cout << "Handling " #message ": " << msg << std::endl; \
    }

#define DISPATCH_MESSAGE(message)   \
    if (msgType == #message) {      \
        handle_##message(msg);      \
        return;                     \
    }

HANDLE_MESSAGE(Login)
HANDLE_MESSAGE(Logout)
HANDLE_MESSAGE(Register)

void dispatchMessage(const std::string& msgType, const std::string& msg) {
    DISPATCH_MESSAGE(Login)
    DISPATCH_MESSAGE(Logout)
    DISPATCH_MESSAGE(Register)

    std::cout << "Unknown message type: " << msgType << std::endl;
}

int main() {
    dispatchMessage("Login", "User123 logged in");      // 输出 "Handling Login: User123 logged in"
    dispatchMessage("Register", "New user registered"); // 输出 "Handling Register: New user registered"
    dispatchMessage("Logout", "User123 logged out");    // 输出 "Handling Logout: User123 logged out"
    dispatchMessage("Unknown", "Unknown message");      // 输出 "Unknown message type: Unknown"

    return 0;
}

解释：

HANDLE_MESSAGE(Login) 宏生成了一个 handle_Login 函数，用于处理 Login 类型的消息。
DISPATCH_MESSAGE 宏用于在消息分发函数中，根据消息类型调用相应的处理函数。

总结

通过以上复杂的使用案例，你可以看到 ## 令牌粘合运算符在 C++ 中具有强大的应用场景。它能帮助开发者自动生成代码、简化重复任务，特别是在处理动态生成标识符、自动化对象创建和管理方面非常有用。然而，使用 ## 运算符时也要小心，确保拼接后的标识符是合法且易于维护的。此外，应始终考虑代码的可读性和可维护性，尽量避免过度复杂的宏定义，并在可能的情况下使用现代 C++ 特性代替宏。

Thomas_Lbw