容器的模板语法

Question

这就是我现在拥有的：

template<template<typename T> class container, typename T>
inline bool contains( const container<T> &cont, const T &element )
{
    if( cont.size() == 0 )
        return false;

    return( std::find(cont.begin(), cont.end(), element) != cont.end() );
}

我想这样称呼它：

std::vector<string> stringvector;
contains( stringvector, "somestring" );

我相信这应该是可能的，但我尝试过的一切都会引发不同的错误。任何帮助表示赞赏。谢谢！

更新：感谢所有答案，我看得太远了，但我仍然遇到问题：

template<class container_type, typename T>
inline bool contains(const container_type& c, const T& e)
{
    return !(c.size() && std::find(c.begin(),c.end(),e)!=c.end());
}

int main(int argc, char *argv[])
{
    vector<string> stringvector;
    stringvector.push_back("hello");
    cout << contains( stringvector, string("hello") );
    return 0;
}

编译失败，即使没有显式的 `string´ 构造函数：

error: no matching function for call to 'find(std::vector<std::basic_string<char> >::const_iterator, std::vector<std::basic_string<char> >::const_iterator, const std::basic_string<char>&)'

Answer 1

STL 容器采用两个 参数，一个用于包含的类型，另一个用于描述如何获取内存的分配器。

试试这个：

template<template<typename T, typename Alloc> class container, typename T, typename Alloc>
inline bool contains( const container<T, Alloc > &cont, const T &element )

但是，这确实是一个很好的例子，说明了为什么您应该完全避免在容器上对算法进行参数化。最好遵循<algorithm>的模式，只指定迭代器类型参数。

template< typename Iter, typename T >
inline bool contains( Iter first, Iter last, const T &element )
    { return std::find( first, last, element ) != last; }

如果您必须要求提供容器，请不要费心指定容器的外观。假设它有你想要的界面。这对你来说是最简单的，对用户来说也是最灵活的。

template< typename Cont, typename T >
inline bool contains( Cont const &cont, T const &element )
    { return std::find( cont.begin(), cont.end(), element ) != cont.end(); }

Answer 2

为什么不直接

template<class container_type,typename T>
inline bool contains(const container_type& c,const T& e) {
    return !(c.size() && std::find(c.begin(),c.end(),e)!=c.end());
}

Answer 3

试试：

template <class T> 
bool contains(const T & cont, const typename T::value_type & elem)
{
   return( std::find(cont.begin(), cont.end(), elem) != cont.end() );
}

大多数标准容器都有一个value_type typedef，可以简化这一点。

Answer 4

比这更简单...只需将容器和包含的元素类型视为模板参数...

#include <vector>
#include <list>
#include <set>
#include <string>
#include <algorithm>
#include <iostream>

template<typename C, typename E>
bool contains(const C& c, const E& e)
{
    return std::find(c.begin(), c.end(), e) != c.end();
}

int main()
{
    std::vector<std::string> V;
    std::list<std::string> L;
    std::set<std::string> S;

    V.push_back("Foo"); L.push_back("Foo"); S.insert("Foo");
    V.push_back("Bar"); L.push_back("Bar"); S.insert("Bar");

    std::cout << contains(V, "Foo") << std::endl;
    std::cout << contains(L, "Foo") << std::endl;
    std::cout << contains(S, "Foo") << std::endl;

    std::cout << contains(V, "Baz") << std::endl;
    std::cout << contains(L, "Baz") << std::endl;
    std::cout << contains(S, "Baz") << std::endl;

    return 0;
}

但是请注意，例如在上面的代码中，我同时使用contains 和std::set，其中std::find 不是搜索事物的聪明方法（std::set::find 可以做得比 O(n) 更好） .