C++单例模版 template＜typename T＞

template<typename T> 是 C++ 中模板编程的一种用法，它允许你编写与数据类型无关的通用代码。模板可以被视为一种创建类或函数的蓝图，这些类或函数可以处理任何类型，只要在实例化时指定了具体的类型。

什么是模板？

模板是一种支持泛型编程的工具，它允许你编写代码时不指定具体的数据类型，而是在编译时根据需要自动确定类型。

模板的用途

1. 代码复用：通过使用模板，你可以编写一个函数或类，它可以用于多种数据类型，而不需要为每种类型编写重复的代码。
2. 类型安全：模板保证了类型匹配，避免了类型转换的错误。
3. 性能：由于模板在编译时就确定了类型，因此没有运行时的类型检查开销，这可以提高程序的执行效率。

示例

假设我们想要编写一个函数，它可以交换两个变量的值。我们可以使用模板来创建一个通用的交换函数，它可以用于任何数据类型。

#include <iostream>

// 模板函数声明
template<typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10;
    int y = 20;
    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
    swap(x, y);
    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    double m = 7.5;
    double n = 2.5;
    std::cout << "Before swap: m = " << m << ", n = " << n << std::endl;
    swap(m, n);
    std::cout << "After swap: m = " << m << ", n = " << n << std::endl;

    return 0;
}

在这个例子中，swap 函数是一个模板函数，它使用 template<typename T> 声明。这意味着 swap 函数可以接受任何类型的参数（如 int、double 等），并在编译时自动确定具体的类型 T。

当你调用 swap(x, y) 时，编译器会看到 x 和 y 是 int 类型，因此它会生成一个专门用于 int 类型的 swap 函数版本。同样，当你调用 swap(m, n) 时，它会生成一个专门用于 double 类型的版本。

这就是模板的魔力：编写一次代码，却可以用于多种类型。

假如已经定义了该单例模版函数，实际要怎么使用？

要使用已经定义的单例模板类 Singleton，你需要首先确保你的类继承自 Singleton 模板，并指定具体的类型。然后，你可以使用 getInstance 方法来获取类的实例。

下面是一个实际使用 Singleton 模板的例子。假设我们有一个名为 Logger 的类，我们希望它以单例模式工作：

#include <iostream>

// 定义单例模板
template<typename T>
class Singleton {
private:
    static T* instance;
    Singleton() {}
    ~Singleton() {}

public:
    static T* getInstance() {
        if (instance == nullptr) {
            instance = new T();
        }
        return instance;
    }
};

// 为每种类型初始化静态成员变量
template<typename T>
T* Singleton<T>::instance = nullptr;

// Logger 类
class Logger {
public:
    void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

// 将 Logger 变为单例
typedef Singleton<Logger> LoggerSingleton;

int main() {
    // 获取 Logger 类的单例实例
    Logger* logger1 = LoggerSingleton::getInstance();
    logger1->log("This is the first log message.");

    // 再次获取 Logger 类的单例实例
    Logger* logger2 = LoggerSingleton::getInstance();
    logger2->log("This is the second log message.");

    // 检查两个实例是否相同
    if (logger1 == logger2) {
        std::cout << "logger1 and logger2 are the same instance." << std::endl;
    }

    return 0;
}

在这个例子中，我们首先定义了 Logger 类，它有一个 log 方法用于输出日志信息。然后，我们使用 typedef 将 Singleton<Logger> 定义为 LoggerSingleton，这样我们就可以通过 LoggerSingleton 来创建 Logger 类的单例。

在 main 函数中，我们通过 LoggerSingleton::getInstance() 获取 Logger 类的实例，并调用 log 方法输出日志。由于 Logger 类是通过 Singleton 模板创建的单例，所以无论我们多少次调用 getInstance 方法，它都只会创建一个 Logger 类的实例，因此 logger1 和 logger2 实际上是指向同一个对象的指针。

输出将是：

Log: This is the first log message.
Log: This is the second log message.
logger1 and logger2 are the same instance.

这个例子展示了如何使用单例模板类来确保全局只有一个类的实例。