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）好。

容器的模板语法

4 个答案: