从另一个容器创建容器，在 C++ 中对每个元素应用一些函数

Question

我的问题很简单，看例子：

std::array<int,6> a = {{0,1,2,3,4,5}}; // -- given container.
auto F = []( int i ) { return  i*i; }; // -- given function.

std::vector<int> v;  // need create

// my solution:
v.reserve( a.size () );
for( std::size_t i = 0; i < a.size(); ++i )
    v.push_back( F(a[i]) ); 



// but I need something like
   std::vector<int>v( a.begin(), a.end(), <|applying each element to F|> );

我可以创建类似上面的容器，而不是显式调用 Reserve 和任何重新分配吗？

编辑：

1. 我想避免保留；因为在其他情况下我的第一个解决方案很好 对我来说:)
2. 我想避免任何调整大小；因为它每个都被初始化 元素默认为ctor。
3. 我将在实际项目中使用它，其中可能包含许多 3 方库（boost、Soft-STL、...）。

Answer 1

标准算法std::transform正是这样做的！

std::vector<int> v(a.size());
std::transform(
   std::begin(a), std::end(a),
   std::begin(v),
   F
);

如果您愿意，可以从一个空向量开始并使用std::back_inserter：

std::vector<int> v;
std::transform(
   std::begin(a), std::end(a),
   std::back_inserter(v),
   F
);

但是如果你这样做，你就会让自己遭受不必要的重新分配（除非你首先reserve，就像你最初的尝试一样）。你可以自己决定你的优先级是什么。

Answer 2

使用std::transform:

#include <algorithm> // std::transform
#include <iterator>  // std::back_inserter

....

transform(a.begin(), a.end(), back_inserter(v), F);

您可能需要先致电v.reserve(asize()) 以避免重新分配。

Answer 3

另一种解决方案是使用boost::transform_iterator。好处是您可以将迭代器传递给容器构造函数。与使用std::back_inserter 或必须在目标上调用reserve 或resize 相比，这避免了内存重新分配。一言以蔽之：

std::vector<int> result(
      boost::make_transform_iterator(std::begin(a), F)
    , boost::make_transform_iterator(std::end(a), F)
    );

---

您可以实现更简洁的语法，如下所示：

std::vector<int> result(transform_range(a, F));

transform_range 实现：

template<class Iterator>
struct AutoSequence
{
    Iterator const beg_, end_;

    template<class T>
    operator std::vector<T>() const {
        return {beg_, end_};
    }
};

template<class Function, class InSeq>
auto transform_range(InSeq const& in) -> AutoSequence<decltype(boost::make_transform_iterator<Function>(in.begin()))> {
    return {
          boost::make_transform_iterator<Function>(std::begin(in))
        , boost::make_transform_iterator<Function>(std::end(in))
        };
}

template<class Function, class InSeq>
auto transform_range(InSeq const& in, Function&& f) -> AutoSequence<decltype(boost::make_transform_iterator(in.begin(), f))> {
    return {
          boost::make_transform_iterator(std::begin(in), f)
        , boost::make_transform_iterator(std::end(in), f)
        };
}