容器的模板语法

template syntax for containers

本文关键字：语法      更新时间：2023-10-16

现在是这样的:

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>&)'

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(); }

为什么不直接

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());
}

尝试:

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类型定义，简化了这一点。

其实更简单…只要把容器和所包含的元素类型当作模板参数…

#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)做得更好)。

相关文章：