2

我有一个很大的std::vector<int> a，但我只想处理它的一个子集。这个想法是创建一个std::vector<reference_wrapper<int> > refa只包含上述子集的（在 mwe 中，所有元素 1 a<<4）。然后我想传递refa给期望 astd::vector<int>或std::vector<int>&作为参数的函数（因为我也想将它们与 一起使用a）。a可能会很大，我想避免多次选择。

问题

如何正确传递refa给函数？我想要的是bar(refa)和foobar(refa)工作。

有没有更好的方法来解决问题，而不改变功能（太多）？

代码

#include <functional>
#include <iostream>
#include <vector>


int foo(int &a)
{
  a++;
  return 0;
}

int bar(std::vector<int> &va)
{
  for(auto &vaa : va)
    vaa++;

  return 0;
}

int foobar(std::vector<int> va)
{
  for(auto &vaa : va)
    vaa++;

  return 0;
}



int main()
{
  std::vector<int> a= {1, 2, 3, 4, 5};
  std::vector<std::reference_wrapper<int> > refa;

  //Fill refa
  for(auto &aa : a)
    {
      if(aa>1 && aa<4) refa.push_back(std::ref(aa));
    }


  //works
  // for(auto &aa : refa)
  //   aa++;

  //works
  //  bar(a);

  //works, a unchanged
  //  foobar(a);

  //works
  // for(auto &aa : refa)
  //   foo(aa);

  //works                         
  // for(int &aa : refa)
  //  foo(aa)

  // does not work
  // conversion from vector<reference_wrapper<int> > to vector<int>& or vector<int> required
  bar(refa);
  //  foobar(refa);


  for(auto &aa : a)
    std::cout << aa << std::endl;


  return 0;
}

注意 int在这里仅用于保持示例简单。

4

3 回答 3

5

我肯定会使用迭代器，特别是考虑到您的问题（处理向量的子集）：

template<class Iterator>
int bar(Iterator begin, Iterator end)
{
    for (auto it = begin; it != end; ++it)
        (*it)++;
    return 0;
}

这样您不仅可以从容器中抽象出来，而且还可以轻松地从经典的“开始”和“结束”迭代器中传递不同的迭代器来模拟特定的范围：

bar(a.begin() + 2, a.begin() + 4);

例如，使用上面的代码，您将访问 1 到 4 的元素（均不包括在内）。这是一个活生生的例子。

于 2014-02-11T17:01:01.170 回答
3

最好的办法是使函数 bar 和 foobar 模板函数，如下所示： 

template <typename TContainer> 
int bar(TContainer& va)
{
    for(auto& vaa : va)
        vaa++;

    return 0;
}

如果不重新定义你的函数来接受“看起来像向量的类型”，我认为没有办法实现你想要的。

于 2014-02-11T16:49:55.213 回答
1

如果您不需要容器，请不要使用容器。使用可迭代范围。

容器既是可迭代的范围，又是其内容的所有者。

在 a 的情况下vector，它是一个连续的可迭代范围和内容的所有者。很可能你只需要知道你的实现代码中是否是一个随机访问的可迭代范围。

但是，处理任意连续的可迭代范围是有代价的，因为您必须将实现放在模板头文件中，或者进行昂贵的类型擦除。解决此问题的两种方法是使用您仅接受 a 的子范围的vector事实，或者使用您仅接受连续范围的子范围的事实。

我自己喜欢连续范围的想法：

template<typename T>
struct contiguous_range {
  T* b; T* e;
  contiguous_range( contiguous_range const& ) = default;
  contiguous_range():b(nullptr), e(nullptr) {};
  contiguous_range& operator=( contiguous_range const& ) = default;
  std::size_t size() const { return e-b; }
  T* begin() const { return b; } // note, T*
  T* end() const { return e; } // note, T*
  template<typename U, typename=typename std::enable_if<
    sizeof(U)==sizeof(T)
    && std::is_convertible<U*, T*>::value
  >::type>
  contiguous_range( contiguous_range<U> const& o ):b(o.b), e(o.e) {};
  T& operator[]( std::size_t i ) const { return b[i]; }

  template<typename A>
  contiguous_range( std::vector<T, A> const& v ):b(v.data()), e(v.data()+v.size()) {}
  template<typename U, std::size_t N, typename=typename std::enable_if<
    sizeof(U)==sizeof(T)
    && std::is_convertible<U*, T*>::value
  >::type>
  contiguous_range( std::array<U, N> const& a ):b(a.data()), e(a.data()+a.size()) {}
  template<typename U, std::size_t N, typename=typename std::enable_if<
    sizeof(U)==sizeof(T)
    && std::is_convertible<U*, T*>::value
  >::type>
  contiguous_range( U(&a)[N] ):b(&a[0]), e((&a[0])+N) {}

  template<typename U, typename=typename std::enable_if<
    sizeof(U)==sizeof(T)
    && std::is_convertible<U*, T*>::value
  >::type>
  contiguous_range( U* b_, U* e_ ):b(b_), e(e_) {}
};

template<typename I>
auto contiguous_subrange( I b, I e )
-> contiguous_range<std::iterator_traits<I>::value_type>
{
  return {&*b, &*e};
}
template<typename C>
auto contiguous_subrange( C&& c, std::size_t start, std::size_t end )
-> decltype( contiguous_subrange( &c[start], &c[end] ) )
  { return ( contiguous_subrange( &c[start], &c[end] ) ) };

现在，我们的函数可以简单地采用contiguous_range<int>or continguos_range<const int>，并且可以隐式传递 a std::vector<int>。

您还可以设置std::vector同样连续的子范围。

请注意，aconstiguous_range<int>对应于 a std::vector<int>&，acontiguous_range<const int>对应于 a std::vector<int> const&。

于 2014-02-11T20:10:36.047 回答