C++ C+中的模板函数+；对于不可变数组

我试图创建一个模板函数，如果存在来自不可变数组的值，该函数将返回true，否则返回false。代码如下：

#include <algorithm>

using std::find;

#include <vector>

using std::vector;

template<class T>
bool contains(const T *arr, int size, T val) {
    vector<T> dest(arr, arr + size);

    T *p = find(dest.begin(), dest.end(), val);

    if (p == arr + size)
        return false;
    else
        return true;
}

#包括
使用std：：find；
#包括
使用std：：vector；
模板
布尔包含（常数T*arr、整数大小、T值）{
向量dest（arr，arr+大小）；
T*p=find（dest.begin（），dest.end（），val）；
如果（p==arr+大小）
返回false；
其他的
返回true；
}

每次我针对一个简单的测试程序进行编译时，都会出现以下错误：

main.cpp:10:   instantiated from 'void testit(const T*, int, T) [with T = char]'
main.cpp:37:   instantiated from here
main.cpp:69: error: cannot convert '__gnu_cxx::__normal_iterator<char*, std::vector<char, std::allocator<char> > >' to 'char*' in initialization
main.cpp: In function 'bool contains(const T*, int, T) [with T = int]':
main.cpp:10:   instantiated from 'void testit(const T*, int, T) [with T = int]'
main.cpp:43:   instantiated from here
main.cpp:69: error: cannot convert '__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >' to 'int*' in initialization
main.cpp: In function 'bool contains(const T*, int, T) [with T = std::string]':
main.cpp:10:   instantiated from 'void testit(const T*, int, T) [with T = std::string]'
main.cpp:44:   instantiated from here

main.cpp:10:从“void testit（const T*，int，T）[with T=char]实例化”
main.cpp:37：从此处实例化
main.cpp:69:错误：无法在初始化中将“\uu gnu\u cxx:：\uuu normal\u iterator”转换为“char*”
main.cpp:在函数“bool contains（const T*，int，T）[带T=int]”中：
main.cpp:10：从“void testit（const T*，int，T）[with T=int]实例化”
main.cpp:43：从此处实例化
main.cpp:69:错误：无法在初始化中将“\uu gnu\u cxx:：\uuu normal\u iterator”转换为“int*”
main.cpp:在函数“bool contains（const T*，int，T）[with T=std:：string]”中：
main.cpp:10：从“void testit（const T*，int，T）[with T=std:：string]实例化”
main.cpp:44：从此处实例化

（所有这些错误都在包含

find

功能的行上）

最好的办法是什么？向量是必要的吗

向量是必要的吗

没有

模板
布尔包含（常数T*arr、整数大小、T值）{
return std:：find（arr，arr+size，val）！=arr+size；
}

向量是必要的吗

没有

模板
布尔包含（常数T*arr、整数大小、T值）{
return std:：find（arr，arr+size，val）！=arr+size；
}

错误：无法在初始化中将“\uu gnu\u cxx:：\uuu normal\u iterator>>”转换为“char*”

这说明您的返回类型对于

std:：find

不正确

对于您拥有的代码，您应该具有如下内容

template<class T>
bool contains(const T *arr, int size, T val)
{
    vector<T> dest(arr, arr + size);

    vector<T>::iterator p = find(dest.begin(), dest.end(), val);

    return p != dest.end();
}

模板
布尔包含（常数T*arr、整数大小、T值）
{
向量dest（arr，arr+大小）；
向量：：迭代器p=find（dest.begin（），dest.end（），val）；
返回p！=dest.end（）；
}

向量是必要的吗

不，可以简化如下

template<class T>
bool contains(const T *arr, int size, T val)
{
    const T* end = arr + size;
    return find(arr, end, val) != end;
}

模板
布尔包含（常数T*arr、整数大小、T值）
{
常数T*end=arr+size；
返回查找（arr，end，val）！=end；
}

错误：无法在初始化中将“\uu gnu\u cxx:：\uuu normal\u iterator>>”转换为“char*”

这说明您的返回类型对于

std:：find

不正确

对于您拥有的代码，您应该具有如下内容

template<class T>
bool contains(const T *arr, int size, T val)
{
    vector<T> dest(arr, arr + size);

    vector<T>::iterator p = find(dest.begin(), dest.end(), val);

    return p != dest.end();
}

模板
布尔包含（常数T*arr、整数大小、T值）
{
向量dest（arr，arr+大小）；
向量：：迭代器p=find（dest.begin（），dest.end（），val）；
返回p！=dest.end（）；
}

向量是必要的吗

不，可以简化如下

template<class T>
bool contains(const T *arr, int size, T val)
{
    const T* end = arr + size;
    return find(arr, end, val) != end;
}

模板
布尔包含（常数T*arr、整数大小、T值）
{
常数T*end=arr+size；
返回查找（arr，end，val）！=end；
}

如果参数不是实际的、完整的数组，则T.C.的答案是可靠的（尽管通过引用获取值是一个好主意），但如果您只想支持整个数组，则可以使用一些更易于使用的参数，并从数组的类型中提取数组大小：

template <class T, size_t N>
inline bool contains(const T(&arr)[N], const T& val)
{
    return std::find(arr, arr + N, val) != arr + N;
}

模板
内联布尔包含（常量T和arr）[N]，常量T和val）
{
return std:：find（arr，arr+N，val）！=arr+N；
}

---

当然，这两个版本都可以重载。

如果参数不是实际的完整数组，则T.C.的答案是可靠的（尽管通过引用获取值是一个好主意），但如果您只想支持整个数组，则可以使用更简单的方法，从数组的类型中提取数组大小：

template <class T, size_t N>
inline bool contains(const T(&arr)[N], const T& val)
{
    return std::find(arr, arr + N, val) != arr + N;
}

模板
内联布尔包含（常量T和arr）[N]，常量T和val）
{
return std:：find（arr，arr+N，val）！=arr+N；
}

当然，您可以重载这两个版本