如何阻止模板类contain被std::stack<T>实例化或规避调用问题

你遇到的核心问题很明确：std::stack是一种适配器容器，它并没有暴露push_back、begin、end这些序列容器的成员函数，而你的contain类默认假设所有传入的容器都支持这些操作。下面给你三种实用的解决方案，你可以根据自己的需求选择：

方案1：静态断言直接阻止std::stack实例化 #

如果你完全不想让contain被std::stack实例化，最直接的方式是在类内部添加编译期检查，一旦检测到容器类型是std::stack就直接报错。

修改后的代码如下：

#include <type_traits>
#include <stack>

template<typename T, template <typename...> typename U>
class contain {
public:
    contain() : _container() { }
    ~contain() { }
    
    void push(T const&data) { this->_container.push_back(data); }
    void aff() { std::for_each(_container.begin(), _container.end(), [](T &var) {::aff(var);}); }
    void add() { std::for_each(_container.begin(), _container.end(), [](T &var) {::add(var);}); }

private:
    U<T> _container;
    // 编译期断言：禁止用std::stack实例化contain
    static_assert(!std::is_same_v<U<T>, std::stack<T>>, 
                  "contain cannot be instantiated with std::stack (it doesn't support required methods)");
};

这个方案的好处是编译期就能明确报错，避免运行时的意外问题；缺点是完全切断了contain与std::stack的兼容可能。

方案2：用SFINAE/Concepts给方法添加约束 #

如果你希望contain能兼容多种容器（包括std::stack），但只给支持对应操作的容器启用特定方法，可以用SFINAE（C11+）或者Concepts（C20+）来实现条件编译。

2.1 C++11/14 版本（SFINAE） #

通过decltype和逗号表达式，只有当容器支持目标操作时，对应的方法才会被实例化：

#include <type_traits>
#include <algorithm>
#include <stack>

template<typename T, template <typename...> typename U>
class contain {
public:
    contain() : _container() { }
    ~contain() { }

    // 仅当容器有push_back时，才启用这个push方法
    template<typename Container = U<T>>
    auto push(T const&data) -> decltype(std::declval<Container>().push_back(data), void()) {
        this->_container.push_back(data);
    }

    // 仅当容器支持begin/end时，才启用aff方法
    template<typename Container = U<T>>
    auto aff() -> decltype(std::begin(std::declval<Container>()), std::end(std::declval<Container>()), void()) {
        std::for_each(_container.begin(), _container.end(), [](T &var) {::aff(var);});
    }

    // 同理add方法
    template<typename Container = U<T>>
    auto add() -> decltype(std::begin(std::declval<Container>()), std::end(std::declval<Container>()), void()) {
        std::for_each(_container.begin(), _container.end(), [](T &var) {::add(var);});
    }

    // 给std::stack单独适配push方法
    void push(T const&data) {
        static_assert(std::is_same_v<U<T>, std::stack<T>>, "This overload is only for std::stack");
        this->_container.push(data);
    }

private:
    U<T> _container;
};

这样，当你用std::stack实例化contain时，aff和add方法会因为不满足条件而不会被编译（如果调用它们会报错），但push方法会使用专门适配stack的重载。

2.2 C++20 版本（Concepts，更简洁） #

如果你的项目可以用C++20，用Concepts来约束容器类型会更直观：

#include <concepts>
#include <algorithm>
#include <stack>

// 定义一个概念：要求容器支持push_back、begin、end
template<typename C>
concept SequenceContainer = requires(C c, typename C::value_type v) {
    c.push_back(v);
    c.begin();
    c.end();
};

template<typename T, template <typename...> typename U>
class contain {
public:
    contain() : _container() { }
    ~contain() { }

    // 仅给序列容器启用push_back版本的push
    void push(T const&data) requires SequenceContainer<U<T>> {
        this->_container.push_back(data);
    }

    // 给std::stack单独适配push
    void push(T const&data) requires std::is_same_v<U<T>, std::stack<T>> {
        this->_container.push(data);
    }

    // 仅给序列容器启用aff
    void aff() requires SequenceContainer<U<T>> {
        std::for_each(_container.begin(), _container.end(), [](T &var) {::aff(var);});
    }

    // 仅给序列容器启用add
    void add() requires SequenceContainer<U<T>> {
        std::for_each(_container.begin(), _container.end(), [](T &var) {::add(var);});
    }

private:
    U<T> _container;
};

Concepts让代码的可读性大大提升，约束条件一目了然。

方案3：类模板特化，给std::stack定制完整实现 #

如果你想给std::stack的contain实例完全定制所有方法的行为，可以用类模板特化：

#include <algorithm>
#include <stack>
#include <vector>

// 主模板：针对普通序列容器
template<typename T, template <typename...> typename U>
class contain {
public:
    contain() : _container() { }
    ~contain() { }
    
    void push(T const&data) { this->_container.push_back(data); }
    void aff() { std::for_each(_container.begin(), _container.end(), [](T &var) {::aff(var);}); }
    void add() { std::for_each(_container.begin(), _container.end(), [](T &var) {::add(var);}); }

private:
    U<T> _container;
};

// 针对std::stack的特化版本
template<typename T>
class contain<T, std::stack> {
public:
    contain() : _container() { }
    ~contain() { }

    // 适配stack的push方法
    void push(T const&data) { this->_container.push(data); }

    // 自定义aff：遍历stack需要先复制到临时容器（因为stack不支持迭代器）
    void aff() {
        std::stack<T> temp_stack = _container;
        while (!temp_stack.empty()) {
            ::aff(temp_stack.top());
            temp_stack.pop();
        }
    }

    // 同理add方法
    void add() {
        std::stack<T> temp_stack = _container;
        while (!temp_stack.empty()) {
            ::add(temp_stack.top());
            temp_stack.pop();
        }
    }

private:
    std::stack<T> _container;
};

这个方案的好处是可以给std::stack的contain实例完全定制逻辑，比如遍历stack时可以自己实现迭代逻辑；缺点是需要单独维护特化版本的代码，如果contain的主模板有修改，特化版本可能也要同步更新。

内容的提问来源于stack exchange，提问作者Comte_Zero