在 C++ 中的模板函数中初始化自动（未知）类型的向量

Question

我有一个模板函数，我想在其中生成一个未知类型的向量。我试图让它自动，但编译器说它是不允许的。

模板函数获取迭代器或指针，如在随后的主函数内的测试程序中所见。如何解决问题？

template<class Iter>
auto my_func(Iter beg, Iter end)
{
    if (beg == end)
        throw domain_error("empty vector");

    auto size = distance(beg, end);

    vector<auto> temp(size); // <--HERE COMPILER SAYS CANNOT BE AUTO TYPE
    copy(beg, end, temp->begin);
    .
    .
    return ....

}


int main()
{
    int bips[] = {3, 7, 0, 60, 17}; // Passing pointers of array
    auto g = my_func(bips, bips + sizeof(bips) / sizeof(*bips));

    vector<int> v = {10, 5, 4, 14}; // Passing iterators of a vector
    auto h = my_func(v.begin(), v.end());

    return 0;
}

Answer 1

您不能使用 std::vector 或 auto。你可以改用std::iterator_traits：

std::vector<typename std::iterator_traits<Iter>::value_type> temp(size);

Answer 2

如果您有兼容 C++17 的编译器，您可能会从 class template argument deduction 中受益。

所以除非你有特定的理由用std::copy 填充你的向量，你可以这样写你的代码：

template<class Iter>
auto my_func(Iter beg, Iter end)
{
    if (beg == end)
        throw domain_error("empty vector");

    vector temp(beg, end);
    // do the remaining stuff
    return ....
}

如果您的编译器没有此功能，那么我会投票支持

vector<typename iterator_traits<Iter>::value_type> temp(beg, end);

点赞in Jonathan's answer

Answer 3

您可能正在寻找类似的东西

std::vector<typename std::remove_reference<decltype(*beg)>::type> temp(beg, end);

Demo

Answer 4

auto 不起作用的原因是因为它在这种情况下是不允许的。您不能提供 auto 来代替模板参数。当您希望编译器自动推断模板参数时，正确的做法是根本不提供参数。但是，在这种情况下，编译器无法推断出该类型应该是什么。您必须明确提供类型。

有很多方法可以找出向量的正确类型。您可以使用std::iterator_traits 获取有关迭代器的信息，包括它所引用的值的类型。你会使用typename std::iterator_traits<Iter>::value_type。

#include <algorithm>
#include <iterator>
#include <stdexcept>
#include <vector>

template<class Iter>
auto my_func(Iter beg, Iter end)
{

    if (beg == end)
        throw std::domain_error("empty vector");

    auto size = std::distance(beg, end);

    using t_value = typename std::iterator_traits<Iter>::value_type;
    std::vector<t_value> temp(size);

    std::copy(beg, end, temp.begin());

    return temp;
}


int main()
{

    int bips[] = { 3,7,0,60,17 };//Passing pointers of array
    auto g = my_func(bips, bips + sizeof(bips) / sizeof(*bips));

    std::vector<int> v = { 10,5,4,14 };//Passing iterators of a vector 
    auto h = my_func(v.begin(), v.end());

    return 0;
}

我想指出，没有理由检查 0 尺寸范围。它会正确返回一个空向量。

您还可以利用std::vector 具有接受一对迭代器并复制该范围的构造函数这一事实，大大简化my_func 的主体。

template<class Iter>
auto my_func(Iter beg, Iter end)
{
    using t_value =typename std::iterator_traits<Iter>::value_type;
    return std::vector<t_value>(beg, end);
}

Answer 5

您可以使用iterator_traits 提取指针/iterator 的类型信息。 value_type 是您感兴趣的特定特征，因此您可以这样做：

const vector<typename iterator_traits<Iter>::value_type> temp(beg, end);

Live Example

Answer 6

类型未知是不正确的。您要创建的向量类型与Iter相同。

只需使用decltype 或使用迭代器类型特征 获取iter 基础类型，如下所示：

• decltype -> std::vector<typename remove_reference<decltype(*beg)>::type> temp(beg, end);

• iterator type trait

如下

using Type = std::iterator_traits<Iter>::value_type;
std::vector<Type>...

Answer 7

我会以与您的问题似乎要求的方式略有不同的方式解决这个问题。

首先，我发现范围是比采用两个迭代器更好的基本类型。这两个迭代器是耦合的，它们应该是一个参数。范围是两个迭代器的简单结构，带有一些实用方法：

template<class It>
struct range_t:
  std::iterator_traits<It>
{
  It b{}, e{};
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
  auto size() const { return std::distance(begin(), end()); }
  // etc
  range_t()=default;
  range_t(range_t const&)=default;
  range_t(range_t &&)=default;
  range_t& operator=(range_t const&)=default;
  range_t& operator=(range_t &&)=default;
};
template<class It>
range_t<It> make_range( It s, It f ) { return {std::move(s), std::move(f)}; }

range_ts 正确地将开始结束迭代器耦合在一起。

现在

template<class Range>
auto my_func(Range&& range) {
  // todo
}
template<class Iter>
auto my_func(Iter beg, Iter end)
{
   return my_func(make_range(std::move(beg), std::move(end)));
}

是第一步。或者只是完全消除两个迭代器的版本，并期望调用者为您打包他们的迭代器。

template<class Range>
auto my_func(Range&& range) {
  if (range.empty())
    throw domain_error("empty vector");
  // todo
}

好的，现在你想这样做：

auto size = range.size();

vector<auto> temp(size);//<--HERE COMPILER SAYS CANNOT BE AUTO TYPE 
copy(range.begin(), range.end(), temp->begin);

但这是一种常见的操作。所以我们把它写成范围：

template<class Range>
auto as_vector( Range const& r ) {
  using value_type = typename Range::value_type;
  std::vector<value_type> v( range.begin(), range.end() );
  return v;
}

给我们：

template<class Range>
auto my_func(Range&& range) {
  if (range.empty())
    throw domain_error("empty vector");
  auto v = as_vector(range);
  // ...
  return ...;
}

我们已将您的问题分解为有意义的简单原语，并将实现复杂性转移到这些原语中。您的my_func 的“业务逻辑”不再关心您采取哪些步骤将范围变成向量。

这使您的my_func 更具可读性，只要您相信as_vector(range) 实际上将该范围作为向量返回。