转换为常量向量

Transform into a const vector

本文关键字：向量 常量 转换      更新时间：2023-10-16

我手头有一些Foo的向量，我想把它转换成一个Bar s的向量，一个const的向量。我能想到的最好的方法是：

Bar foo2bar(const Foo& foo);
std::vector<Foo> foos = {...};
const std::vector<Bar> bars = [&foos] {
    std::vector<Bar> bars;
    bars.reserve(foos.size());
    std::transform(foos.cbegin(), foos.cend(),
                   std::back_inserter(bars),
                   foo2bar);
    return bars;
}();

而且我认为大多数编译器应该省略 lambda 的返回值，所以这应该接近理想。唯一的缺点可能是需要创建一个 lambda，但我认为这不是太大的问题。

这种方法是否存在任何阴险的问题，是否有更好的方法（例如，更快，更清洁）？C++11可用。

最简单的解决方案是完全放弃const要求。您仍然可以向其他范围公开对const的引用。

如果做不到这一点，这应该没问题。lambda 主体可能会被内联，lambda 的"创建"是一个编译时过程，返回值将被移动或完全省略。实际上，您的方法非常优雅。

如果你真的不能忍受lambda的想法，那么你可以达到boost的transform_iterator：

#include <vector>
#include <boost/iterator/transform_iterator.hpp>
struct Foo {};
struct Bar {};
Bar foo2bar(const Foo& f) {
    return Bar {};
}
int main()
{
    std::vector<Foo> foos = {  };
    using boost::make_transform_iterator;
    const std::vector<Bar> bars (make_transform_iterator(foos.begin(), &foo2bar),
                                 make_transform_iterator(foos.end(), &foo2bar));
}

但是，lambda 在优化后没有性能损失，可以说不那么神秘，所以我鼓励这样做。

或者，

您可以将foo2bar()函数作为转换运算符移动到Foo类中：

struct Bar {};
struct Foo
{
    // conversion opertor
    operator Bar() const
    {
        // code to create Bar bar
        return bar;
    }
};
int main()
{
    std::vector<Foo> foos = {};
    const std::vector<Bar> bars(foos.begin(), foos.end());
}
相关文章：