高效累积

Question

假设我有字符串向量，我想通过 std::accumulate 连接它们。

如果我使用以下代码：

std::vector<std::string> foo{"foo","bar"};
string res=""; 
res=std::accumulate(foo.begin(),foo.end(),res,
  [](string &rs,string &arg){ return rs+arg; });

我可以肯定会有临时对象构造。

在this 的回答中，他们说 std::accumulate 的效果是这样指定的：

通过初始化累加器 acc 来计算结果 初始值 init 然后用 acc = acc + *i 或 acc = 修改它 binary_op(acc, *i) 对于 [first,last) 范围内的每个迭代器 i 顺序。

所以我想知道避免不必要的临时对象构造的正确方法是什么。

一个想法是用这种方式改变 lambda：

[](string &rs,string &arg){ rs+=arg; return rs; }

在这种情况下，我认为我强制有效地连接字符串并帮助编译器（我知道我shouldn't）省略了不必要的副本，因为这应该等同于（伪代码）：

accum = [](& accum,& arg){ ...; return accum; }

因此

accum = & accum;

另一个想法是使用

accum = [](& accum,& arg){ ...; return std::move(accum); }

但这可能会导致类似：

accum = std::move(& accum);

这在我看来非常可疑。

编写此代码的正确方法是什么以最大程度地减少不必要地创建临时对象的风险？我不仅对 std::string 感兴趣，我很高兴有一个解决方案，它可能适用于任何实现了复制和移动构造函数/赋值的对象。

Answer 1

试试下面的

res=std::accumulate(foo.begin(),foo.end(),res,
  [](string &rs, const string &arg) -> string & { return rs+=arg; });

在这个电话之前，也许有一种感觉可以打电话

std::string::size_type n = std::accumulate( foo.begin(), foo.end(), 
   std::string::size_type( 0 ),
   [] ( std::string_size_type n, const std::string &s ) { return ( n += s.size() ); } );

res.reserve( n );

Answer 2

我会将其分解为两个操作，首先是 std::accumulate 获取需要创建的字符串的总长度，然后是带有更新本地字符串的 lambda 的 std::for_each：

std::string::size_type total = std::accumulate(foo.begin(), foo.end(), 0u, 
                [](std::string::size_type c, std::string const& s) {
                    return c+s.size() 
                });
std::string result;
result.reserve(total);
std::for_each(foo.begin(), foo.end(), 
              [&](std::string const& s) { result += s; });

对此的常见替代方法是使用表达式模板，但这不适合答案。基本上，您创建一个映射操作的数据结构，但不执行它们。当表达式最终被评估时，它可以预先收集它需要的信息并使用它来保留空间并进行复制。使用表达式模板的代码更好，但更复杂。

Answer 3

这有点棘手，因为涉及到两个操作， 添加和分配。为了避免复制， 您必须同时修改字符串，和 确保分配是空操作。这是第二部分 这很棘手。

我有时会创建一个自定义“累加器”， 大致如下：

class Accu
{
    std::string myCollector;
    enum DummyToSuppressAsgn { dummy };
public:
    Accu( std::string const& startingValue = std::string() )
        : myCollector( startingValue )
    {
    }
    //  Default copy ctor and copy asgn are OK.
    //  On the other hand, we need the following special operators
    Accu& operator=( DummyToSuppressAsgn )
    {
        //  Don't do anything...
        return *this;
    }
    DummyToSuppressAsgn operator+( std::string const& other )
    {
        myCollector += other;
        return dummy;
    }
    //  And to get the final results...
    operator std::string() const
    {
        return myCollector;
    }
};

致电accumulate 时会有几份副本，其中的 返回值，但在实际积累过程中，什么都没有。只是 调用：

std::string results = std::accumulate( foo.begin(), foo.end(), Accu() );

（如果你真的关心性能，你可以添加 Accu 的构造函数的容量参数，以便它可以 在成员字符串上执行reserve。如果我这样做，我会 可能还要手写复制构造函数，以确保 复制对象中的字符串具有所需的容量。）

Answer 4

在没有任何冗余副本的情况下有效地使用std::accumulate 并不明显。
除了被重新分配并传入和传出 lambda 之外，累积值可能会被实现在内部复制。
另外，请注意 std::accumulate() itself 采用初始值 by-value，调用一个 copy-ctor，因此忽略在副本源上完成的任何 reserve()s（如某些其他答案）。

我发现连接字符串的最有效方法如下：

std::vector<std::string> str_vec{"foo","bar"};

// get reserve size:
auto sz = std::accumulate(str_vec.cbegin(), str_vec.cend(), std::string::size_type(0), [](int sz, auto const& str) { return sz + str.size() + 1; });

std::string res;
res.reserve(sz);
std::accumulate(str_vec.cbegin(), str_vec.cend(),
   std::ref(res), // use a ref wrapper to keep same object with capacity
   [](std::string& a, std::string const& b) -> std::string& // must specify return type because cannot return `std::reference_wrapper<std::string>`.
{                                                           // can't use `auto&` args for the same reason
   a += b;
   return a;
});

结果将在res。
此实现没有冗余副本、移动或重新分配。