Конкатенатные строки, предоставляемые методом класса в C++

Question

Моя проблема довольно проста: у меня есть динамический массив объектов, у которых есть метод , возвращающий строку. Я хочу объединить все эти строки вместе.

Если бы я был массив строк вместо объектов с методом, возвращающим строки, это было бы тривиальная задача:

std::vector<std::string> v{ "f", "o", "o" }; 
std::string const x = std::accumulate(v.begin(), v.end(), std::string()); 

Но в моем случае это скорее выглядит следующим образом:

struct foo 
{ 
    foo(std::string const & name) : name_(name) {} 
    std::string const & name() const { return name_; } 

    private: 
     std::string const name_; 
}; 

std::vector<foo> v{ foo("f"), foo("o"), foo("o") }; 

Я хотел бы использовать стандартные библиотечные алгоритмы, так как я уверен, что это эффективный и что-то, что мне не нужно отлаживать, но это слишком сложно читать и понимать:

std::vector<std::string> transformed(v.size()); 
std::transform(v.begin(), v.end(), transformed.begin(), 
    [](foo const & f) { return f.name(); }); 
std::string const x = std::accumulate(transformed.begin(), transformed.end(), 
    std::string()); 

Будущие Сопровождающие, вероятно (и это справедливо) поохотиться меня пробивать мне в лицо для понапрасну усложняя легкой задачей, которая могла бы быть сделано с:

std::string x; 
for(auto const & f : v) 
    x += f.name(); 

ли там что-то более легкое здесь, чего я не вижу, или это действительно так: , где нужно позволить стандартным библиотекам отдыхать, и использовать цикл for ( , что накапливает в любом случае)?

Answer 1

Если вы настаиваете использовать STL, есть еще одна версия std::accumulate:

template< class InputIt, class T, class BinaryOperation > 
T accumulate(InputIt first, InputIt last, T init, BinaryOperation op); 

Тогда ваш код может стать

std::string const x = std::accumulate(v.begin(), v.end(), std::string(), 
         [](std::string a, foo const& b){return a += b.name();}); 

EDIT: Возможно больше копирования элизии дружественных декларации

Answer 2

Я бы просто использовал подход for loop. Это легче читать, и вам не нужно отлаживать или тестировать (по крайней мере, не на том же уровне, как если бы вы написали свой собственный алгоритм). Просто потому, что это не решение, использующее библиотеку std, не означает, что это разумное решение, которое легко поддерживать.

Answer 3

Вы можете написать оператор + =. Что-то, как

std::string & operator +=(std::string &s, const Foo &f) 
{ 
    return (s += f.name()); 
} 

Answer 4

Я не вижу, как станд :: for_each, станд :: накапливают собираются, чтобы дать вам выигрыш производительности (ваш вектор даже достаточно большой, чтобы это имеет значение?). Возможно, вы захотите провести анализ времени, если это имеет значение для вас.

Я бы хотел читать и ремонтироваться, используя сложность, когда это не критично.