好的，简单的模板问题。假设我定义我的模板类是这样的:

template<typename T>
class foo {
public:
    foo(T const& first, T const& second) : first(first), second(second) {}

    template<typename C>
    void bar(C& container, T const& baz) {
        //...
    }
private:
    T first;
    T second;
}

问题是关于我的 bar 函数...我需要它能够使用某种标准容器，这就是我包含模板/类型名称 C 部分的原因，以定义该容器类型。但显然这不是正确的做法，因为我的测试类然后提示:

错误:“bar”未在此范围内声明

那么我将如何以正确的方式实现我的 bar 功能？也就是说，作为我的模板类的函数，具有任意容器类型......我的模板类的其余部分工作正常(具有不会导致错误的其他函数)，只是那个函数有问题。

编辑: 好的，所以具体的函数(bar)是一个eraseInRange函数，它删除指定范围内的所有元素:

void eraseInRange(C& container, T const& firstElement, T const& secondElement) {...}

如何使用它的一个例子是:

eraseInRange(v, 7, 19);

这里的 v 是一个 vector 。

编辑 2: 傻我!我应该在我的类(class)之外声明这个函数，而不是在里面......这是一个非常令人沮丧的错误。无论如何，感谢大家的帮助，虽然问题有点不同，但信息确实帮助我构建了函数，因为在找到我原来的问题后，我确实得到了一些其他令人愉快的错误。所以谢谢你!

最佳答案

性状解。

泛化不超过需要，也不能少。

在某些情况下，该解决方案可能还不够，因为它会匹配具有此类签名的任何模板(例如 shared_ptr )，在这种情况下，您可以使用 type_traits , 很像 duck-typing (模板通常是鸭子类型的)。​​

#include <type_traits>

// Helper to determine whether there's a const_iterator for T.
template<typename T>
struct has_const_iterator
{
private:
    template<typename C> static char test(typename C::const_iterator*);
    template<typename C> static int  test(...);
public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};


// bar() is defined for Containers that define const_iterator as well
// as value_type.
template <typename Container>
typename std::enable_if<has_const_iterator<Container>::value,
                        void>::type
bar(const Container &c, typename Container::value_type const & t)
{
  // Note: no extra check needed for value_type, the check comes for
  //       free in the function signature already.
}


template <typename T>
class DoesNotHaveConstIterator {};

#include <vector>
int main () {
    std::vector<float> c;
    bar (c, 1.2f);

    DoesNotHaveConstIterator<float> b;
    bar (b, 1.2f); // correctly fails to compile
}

一个好的模板通常不会人为地限制它们有效的类型类型(为什么要这样做？)。但是想象在上面的例子中你需要访问一个对象 const_iterator ，然后您可以使用 SFINAE 和 type_traits 将这些约束放在您的函数上。

或者就像标准库一样

泛化不超过需要，也不能少。

template <typename Iter>
void bar (Iter it, Iter end) {
    for (; it!=end; ++it) { /*...*/ }
}

#include <vector>
int main () {
    std::vector<float> c;
    bar (c.begin(), c.end());
}

有关更多此类示例，请查看 <algorithm> .

这种方法的优势在于其简单性，并且基于 ForwardIterator 等概念。它甚至适用于数组。如果您想直接在签名中报告错误，可以将其与特征结合使用。

std带有 std::vector 等签名的容器(不推荐)

Kerrek SB 已经近似了最简单的解决方案，尽管它是无效的 C++。更正后的变体如下:

#include <memory> // for std::allocator
template <template <typename, typename> class Container, 
          typename Value,
          typename Allocator=std::allocator<Value> >
void bar(const Container<Value, Allocator> & c, const Value & t)
{
  //
}

然而:这仅适用于恰好有两个模板类型参数的容器，因此对于 std::map 将失败。 (感谢 Luc Danton)。

任何类型的辅助模板参数(不推荐)

任何辅助参数计数的更正版本如下:

#include <memory> // for std::allocator<>

template <template <typename, typename...> class Container, 
          typename Value,
          typename... AddParams >
void bar(const Container<Value, AddParams...> & c, const Value & t)
{
  //
}

template <typename T>
class OneParameterVector {};

#include <vector>
int main () {
    OneParameterVector<float> b;
    bar (b, 1.2f);
    std::vector<float> c;
    bar (c, 1.2f);
}

但是:对于非模板容器，这仍然会失败(感谢 Luc Danton)。

关于c++模板类；具有任意容器类型的函数，如何定义它？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7728478/