假设我们有template
template<typename Container, typename T>
bool contains (const Container & theContainer, const T & theReference) {
...
}
如何说明，容器中的元素显然应该是T类型？
这一切都可以缩写（可能在 C ++ 11 中）吗？
答案 0 :(得分：27)
虽然使用value_type的其他答案都是正确的，但这个常见问题的规范解决方案是不首先传递容器：使用标准库语义，传递一对迭代器。
通过传递迭代器，您不必担心容器本身。你的代码也更通用：你可以对范围采取行动，你可以使用反向迭代器，你可以将你的模板与其他标准算法结合起来......：
template<typename Iterator, typename T>
bool contains (Iterator begin, Iterator end, const T& value) {
...
}
int main(){
std::vector<int> v { 41, 42 };
contains(std::begin(v), std::end(v), 42);
};
如果您想查看Iterator所带的类型，可以使用std::iterator_traits：
static_assert(std::is_same<typename std::iterator_traits<Iterator>::value_type, T>::value, "Wrong Type");
（请注意，通常不需要此断言：如果您提供的值与T不相符，则模板将不会首先编译）
最终模板如下：
template<typename Iterator, typename T>
bool contains (Iterator begin, Iterator end, const T& value) {
static_assert(std::is_same<typename std::iterator_traits<Iterator>::value_type, T>::value, "Wrong Type");
while(begin != end)
if(*begin++ == value)
return true;
return false;
}
备注：
1）这不应该是一个惊喜，但我们的contains模板现在具有与std::find（返回迭代器）几乎相同的签名：
template< class InputIt, class T >
InputIt find( InputIt first, InputIt last, const T& value );
2）如果修改原始contains的签名太多，您可以随时将调用转发到我们的新模板：
template<typename Container, typename T>
bool contains (const Container & theContainer, const T & theReference) {
return contains(std::begin(theContainer), std::end(theContainer), theReference);
}
答案 1 :(得分：21)
您可以在模板中限制容器类型：
#include <algorithm>
#include <iostream>
#include <vector>
template< template<typename ... > class Container, typename T>
bool contains(const Container<T>& container, const T& value) {
return std::find(container.begin(), container.end(), value) != container.end();
}
int main()
{
std::vector<int> v = { 1, 2, 3 };
std::cout << std::boolalpha
<< contains(v, 0) << '\n'
<< contains(v, 1) << '\n';
// error: no matching function for call to ‘contains(std::vector<int>&, char)’
contains(v, '0') ;
return 0;
}
更完整的解决方案（解决一些意见）：
#include <algorithm>
#include <array>
#include <iostream>
#include <map>
#include <set>
#include <vector>
// has_member
// ==========
namespace Detail {
template <typename Test>
struct has_member
{
template<typename Class>
static typename Test::template result<Class>
test(int);
template<typename Class>
static std::false_type
test(...);
};
}
template <typename Test, typename Class>
using has_member = decltype(Detail::has_member<Test>::template test<Class>(0));
// has_find
// ========
namespace Detail
{
template <typename ...Args>
struct has_find
{
template<
typename Class,
typename R = decltype(std::declval<Class>().find(std::declval<Args>()... ))>
struct result
: std::true_type
{
typedef R type;
};
};
}
template <typename Class, typename ...Args>
using has_find = has_member<Detail::has_find<Args...>, Class>;
// contains
// ========
namespace Detail
{
template<template<typename ...> class Container, typename Key, typename ... Args>
bool contains(std::false_type, const Container<Key, Args...>& container, const Key& value) {
bool result = std::find(container.begin(), container.end(), value) != container.end();
std::cout << "Algorithm: " << result << '\n';;
return result;
}
template<template<typename ...> class Container, typename Key, typename ... Args>
bool contains(std::true_type, const Container<Key, Args...>& container, const Key& value) {
bool result = container.find(value) != container.end();
std::cout << " Member: " << result << '\n';
return result;
}
}
template<template<typename ...> class Container, typename Key, typename ... Args>
bool contains(const Container<Key, Args...>& container, const Key& value) {
return Detail::contains(has_find<Container<Key, Args...>, Key>(), container, value);
}
template<typename T, std::size_t N>
bool contains(const std::array<T, N>& array, const T& value) {
bool result = std::find(array.begin(), array.end(), value) != array.end();
std::cout << " Array: " << result << '\n';;
return result;
}
// test
// ====
int main()
{
std::cout << std::boolalpha;
std::array<int, 3> a = { 1, 2, 3 };
contains(a, 0);
contains(a, 1);
std::vector<int> v = { 1, 2, 3 };
contains(v, 0);
contains(v, 1);
std::set<int> s = { 1, 2, 3 };
contains(s, 0);
contains(s, 1);
std::map<int, int> m = { { 1, 1}, { 2, 2}, { 3, 3} };
contains(m, 0);
contains(m, 1);
return 0;
}
答案 2 :(得分：19)
对于标准容器，您可以使用value_type：
template<typename Container>
bool contains (const Container & theContainer, const typename Container::value_type& theReference) {
...
}
请注意，您的案例中还有const_reference：
template<typename Container>
bool contains (const Container & theContainer, typename Container::const_reference theReference) {
...
}
答案 3 :(得分：9)
您可以使用value_type
T和static_assert
template<typename Container, typename T>
bool contains (const Container & theContainer, const T & theReference) {
static_assert( std::is_same<typename Container::value_type, T>::value,
"Invalid container or type" );
// ...
}
演示Here
答案 4 :(得分：7)
使用std::enable_if（http://en.cppreference.com/w/cpp/types/enable_if），但比使用static_assert稍微复杂一点。
编辑：根据P0W的评论，使用std::enable_if允许我们使用SFINAE，这在你决定拥有更多重载时很不错。例如，如果编译器决定使用此模板化函数，Container没有value_type typedefed，它将不会立即生成错误，如static_assert那样，只查找其他函数这完全符合签名。
在Visual Studio 12上测试。
#include <vector>
#include <iostream>
template<typename Container, typename T>
typename std::enable_if<
std::is_same<T, typename Container::value_type>::value, bool>::type //returns bool
contains(const Container & theContainer, const T & theReference)
{
return (std::find(theContainer.begin(), theContainer.end(), theReference) != theContainer.end());
};
int main()
{
std::vector<int> vec1 { 1, 3 };
int i = 1;
float f = 1.0f;
std::cout << contains(vec1, i) << "\n";
//std::cout << contains(vec1, f); //error
i = 2;
std::cout << contains(vec1, i) << "\n";
};
输出：
1
0
PS：你的原始函数也是这样做的，除了允许派生类。这些解决方案没有。