如何实现支持多类型的模板化MultiStack？

既然你已经预先知晓允许使用的类型，那我们可以完全抛弃静态局部变量的方案，用C++的编译期特性来实现每个类型独立的栈容器，同时保证线程安全。下面给你两种实用的实现方式：

方式一：固定允许类型的Tuple实现 #

如果允许的类型是固定的（比如int、std::string、double），我们可以用std::tuple来存储对应类型的std::vector，每个MultiStack实例都拥有自己的容器集合，完全避免静态变量的线程竞争问题：

#include <tuple>
#include <vector>
#include <string>
#include <utility> // 用于std::forward

// 预先定义允许的类型对应的容器集合
using AllowedContainers = std::tuple<
    std::vector<int>,
    std::vector<std::string>,
    std::vector<double>
>;

class MultiStack {
private:
    AllowedContainers containers_;

    // 辅助函数：获取对应类型的容器（非const版本）
    template<typename T>
    std::vector<T>& get_container() {
        return std::get<std::vector<T>>(containers_);
    }

    // 辅助函数：获取对应类型的容器（const版本）
    template<typename T>
    const std::vector<T>& get_container() const {
        return std::get<std::vector<T>>(containers_);
    }

public:
    // 获取栈顶元素
    template<typename T>
    const T& Get() const {
        return get_container<T>().back();
    }

    // 压入元素（支持左值）
    template<typename T>
    void Push(const T& t) {
        get_container<T>().push_back(t);
    }

    // 压入元素（支持右值，移动语义）
    template<typename T>
    void Push(T&& t) {
        get_container<T>().push_back(std::forward<T>(t));
    }

    // 弹出栈顶元素
    template<typename T>
    void Pop() {
        get_container<T>().pop_back();
    }
};

这个方案的优势： #

• 线程安全：每个MultiStack实例都有独立的容器集合，没有共享的静态变量，多线程下只要操作各自的实例就不会有竞争问题。
• 类型安全：如果尝试使用不在AllowedContainers中的类型，编译器会直接报错，提前拦截非法类型。
• 零运行时开销：所有容器的访问都是编译期确定的，没有额外的运行时查找成本。

方式二：可变参数模板的通用实现 #

如果你希望MultiStack的允许类型可以在实例化时灵活指定，可以用可变参数模板来定义：

#include <tuple>
#include <vector>
#include <utility>

template<typename... AllowedTypes>
class MultiStack {
private:
    std::tuple<std::vector<AllowedTypes>...> containers_;

    template<typename T>
    std::vector<T>& get_container() {
        return std::get<std::vector<T>>(containers_);
    }

    template<typename T>
    const std::vector<T>& get_container() const {
        return std::get<std::vector<T>>(containers_);
    }

public:
    template<typename T>
    const T& Get() const {
        return get_container<T>().back();
    }

    template<typename T>
    void Push(const T& t) {
        get_container<T>().push_back(t);
    }

    template<typename T>
    void Push(T&& t) {
        get_container<T>().push_back(std::forward<T>(t));
    }

    template<typename T>
    void Pop() {
        get_container<T>().pop_back();
    }
};

// 使用示例
int main() {
    MultiStack<int, std::string, bool> my_stack;
    my_stack.Push(42);
    my_stack.Push(std::string("hello multi stack"));
    my_stack.Push(true);

    auto int_val = my_stack.Get<int>(); // 42
    auto str_val = my_stack.Get<std::string>(); // "hello multi stack"
    
    my_stack.Pop<bool>();
    return 0;
}

这个方案的优势： #

• 高度灵活：实例化时可以自由指定允许的类型，不需要提前定义固定的容器集合。
• 同样具备线程安全和类型安全的特性，编译期完成所有类型检查和容器定位。

为什么这比静态局部变量好？ #

你之前用的静态局部变量方案，本质上是把容器变成了全局共享的（每个类型对应一个全局容器），多线程下如果多个线程同时操作同一个类型的容器，必然会出现竞争问题。而上面的两种方案，每个MultiStack实例都拥有自己的一套容器，完全不存在共享状态，线程安全问题自然就解决了。

内容的提问来源于stack exchange，提问作者non-user38741