Эффективное накопление

Попробуйте следующее

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 );

Я бы разбил это на две операции: сначала std::accumulate для получения общей длины строки, которую необходимо создать, затем 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; });

Распространенной альтернативой этому является использование шаблонов выражений, но это не подходит для ответа. По сути, вы создаете структуру данных, которая отображает операции, но не выполняет их. Когда выражение окончательно вычислено, оно может заранее собрать необходимую информацию и использовать ее для резервирования места и создания копий. Код, использующий шаблон выражения, лучше, но сложнее.

Эффективное использование std::accumulate без каких-либо избыточных копий неочевидно.
Помимо переназначения и передачи в лямбда-выражение и из него, накапливающееся значение может быть скопировано внутри реализации.
Также обратите внимание, что std::accumulate() сам принимает начальное значение по значению, вызывая копию -ctor и, таким образом, игнорируя любые reserve(), выполненные в источнике копии (как предлагается в некоторых других ответах).

Наиболее эффективный способ объединения строк, который я нашел, выглядит следующим образом:

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.
В этой реализации нет избыточных копий, перемещений или перераспределений.

Это немного сложно, так как задействованы две операции: сложение и присваивание. Чтобы избежать копирования, вы должны изменить строку в дополнении, и убедиться, что присваивание не выполняется. Это вторая часть, которая является сложной.

То, что я делал в некоторых случаях, - это создание собственного «аккумулятора» в соответствии с строками:

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 в строке-члене. Если бы я сделал это, я, вероятно, также написал бы конструктор копирования вручную. , чтобы убедиться, что строка в скопированном объекте имеет требуемую емкость.)