Я чув, як кілька людей висловлюють занепокоєння щодо оператора "+" в std :: string та різних обхідних шляхах, щоб прискорити конкатенацію. Чи є щось із цього дійсно необхідне? Якщо так, то який найкращий спосіб об'єднати рядки в C ++?

Додаткових робіт, мабуть, не варто, якщо тільки вам дійсно не потрібна ефективність. Ви, мабуть, матимете набагато кращу ефективність, просто скориставшись оператором + =.

Тепер після цієї відмови, я відповім на ваше фактичне запитання ...

Ефективність класу рядків STL залежить від реалізації використовуваної STL.

Ви можете гарантувати ефективність та більш високий контроль над собою, зробивши конкатенацію вручну за допомогою вбудованих функцій c.

Чому оператор + не ефективний:

Погляньте на цей інтерфейс:

template <class charT, class traits, class Alloc>
basic_string<charT, traits, Alloc>
operator+(const basic_string<charT, traits, Alloc>& s1,
          const basic_string<charT, traits, Alloc>& s2)

Ви можете бачити, що новий об’єкт повертається після кожного +. Це означає, що щоразу використовується новий буфер. Якщо ви робите багато додаткових операцій, це не ефективно.

Чому ви можете зробити це більш ефективним:

• Ви гарантуєте ефективність замість того, щоб довіряти делегату, щоб зробити це ефективно для вас
• клас std :: string нічого не знає про максимальний розмір вашої рядка, а також про те, як часто ви будете поєднувати її. Ви можете мати ці знання і можете робити речі на основі наявності цієї інформації. Це призведе до менших перерозподілів.
• Ви будете керувати буферами вручну, щоб ви могли бути впевнені, що не будете копіювати всю нитку в нові буфери, коли не хочете, щоб це сталося.
• Ви можете використовувати стек для своїх буферів замість купи, що набагато ефективніше.
• Оператор string + створить новий об'єкт string і поверне його звідси за допомогою нового буфера.

Вказівки щодо впровадження:

• Слідкуйте за довжиною струни.
• Зберігайте вказівник на кінець рядка і початок, або просто початок, і використовуйте початок + довжину як зміщення, щоб знайти кінець рядка.
• Переконайтеся, що буфер, в якому ви зберігаєте рядок, достатньо великий, тому вам не потрібно перерозподіляти дані
• Використовуйте strcpy замість strcat, щоб не потрібно перебирати довжину рядка, щоб знайти кінець рядка.

Структура даних канату:

Якщо вам потрібні дійсно швидкі конкатенації, спробуйте скористатися структурою даних мотузки .

Заздалегідь зарезервуйте остаточне місце, а потім використовуйте метод додавання з буфером. Наприклад, скажімо, що ви очікуєте, що остаточна довжина рядка складе 1 мільйон символів:

std::string s;
s.reserve(1000000);

while (whatever)
{
  s.append(buf,len);
}

Я б не переймався цим. Якщо ви робите це в циклі, рядки завжди будуть виділяти пам'ять для мінімізації перерозподілу - просто використовуйте operator+=в цьому випадку. А якщо робити це вручну, щось подібне чи довше

a + " : " + c

Тоді це створює тимчасовості - навіть якщо компілятор міг би усунути деякі копії поверненого значення. Це тому, що в послідовно викликаному operator+він не знає, посилається параметр посилання на названий об'єкт, або тимчасовий, який повертається з додаткового operator+виклику. Я б швидше не хвилювався з цього приводу, перш ніж не профайлювати перший. Але візьмемо приклад для показу цього. Спочатку ми вводимо круглі дужки, щоб зробити ясність чіткою. Я ставлю аргументи безпосередньо після декларації функції, яка використовується для ясності. Нижче я показую, що тоді виходить вираження:

((a + " : ") + c) 
calls string operator+(string const&, char const*)(a, " : ")
  => (tmp1 + c)

Тепер у цьому додатку tmp1є те, що було повернуто першим дзвінком оператору + із показаними аргументами. Ми припускаємо, що компілятор дійсно розумний і оптимізує копію повернутого значення. Отже, ми закінчуємо однією новою рядком, що містить конкатенацію aта " : ". Тепер це відбувається:

(tmp1 + c)
calls string operator+(string const&, string const&)(tmp1, c)
  => tmp2 == <end result>

Порівняйте це з наступним:

std::string f = "hello";
(f + c)
calls string operator+(string const&, string const&)(f, c)
  => tmp1 == <end result>

Він використовує ту саму функцію для тимчасової та для названої рядки! Тож компілятору належить скопіювати аргумент у новий рядок і додати до нього та повернути його з тіла operator+. Він не може зайняти пам'ять тимчасового і додати до цього. Чим більший вираз, тим більше копій струн потрібно зробити.

Далі Visual Studio та GCC підтримуватимуть семантику переміщення c ++ 1x (доповнює семантику копії ) та посилають rvalue як експериментальне доповнення. Це дозволяє з'ясувати, чи параметр посилається на тимчасовий чи ні. Це зробить такі доповнення дивовижно швидкими, оскільки все вищезазначене опиниться в одному "додатковому конвеєрі" без копій.

Якщо це виявиться вузьким місцем, ви все одно можете зробити

 std::string(a).append(" : ").append(c) ...

В appendвиклики додайте аргумент *thisі потім повертає посилання на себе. Тож копіювання часописів там не робиться. Або, як варіант, operator+=можна використовувати, але вам знадобляться потворні дужки, щоб закріпити пріоритет.

Для більшості програм це не має значення. Просто напишіть свій код, блаженно не знаючи, як саме працює + оператор, і візьміть справи лише у свої руки, якщо він стане очевидним вузьким місцем.

На відміну від .NET System.Strings, рядки std :: C ++ є змінними, і тому їх можна будувати за допомогою простого конкатенації так само швидко, як і за допомогою інших методів.

можливо, замість std :: stringstream?

Але я погоджуюсь з думкою, що вам, мабуть, слід просто підтримувати його зрозумілим та зрозумілим, а потім переглядати, чи є у вас справді проблеми.

У Imperfect C ++ Меттью Вілсон представляє динамічний конкатенатор рядків, який попередньо обчислює довжину кінцевої рядки, щоб мати лише один розподіл перед об'єднанням усіх частин. Ми також можемо реалізувати статичний конкатенатор, граючи з шаблонами виразів .

Така ідея була втілена в реалізації STLport std :: string - що не відповідає стандарту через цей точний злом.

std::string operator+виділяє новий рядок і кожен раз копіює два рядки операнда. повторіть багато разів, і це стає дорого, O (n).

std::string appendа operator+=з іншого боку, збільшуйте потужність на 50% кожного разу, коли струна повинна зростати. Що значно зменшує кількість розподілу пам'яті та операцій копіювання, O (log n).

Для невеликих струн це не має значення. Якщо у вас є великі рядки, то краще зберігати їх у вигляді векторів або в іншій колекції як частини. І додайте свій алгоритм для роботи з таким набором даних замість однієї великої рядка.

Я віддаю перевагу std :: ostringstream для складної конкатенації.

Як і в більшості речей, легше щось не робити, ніж робити.

Якщо ви хочете вивести великі рядки в графічний інтерфейс, можливо, те, що ви виходите, може обробляти рядки в шматках краще, ніж у великій рядку (наприклад, об'єднання тексту в текстовому редакторі - зазвичай вони тримають рядки як окремі споруди).

Якщо ви хочете вивести файл, передайте дані, а не створюйте великий рядок і виводячи його.

Я ніколи не знаходжу необхідність зробити конкатенацію швидше необхідною, якщо я видалив із повільного коду непотрібне конкатенацію.

Напевно, найкраща ефективність, якщо ви попередньо виділите (резервуйте) простір у результативному рядку.

template<typename... Args>
std::string concat(Args const&... args)
{
    size_t len = 0;
    for (auto s : {args...})  len += strlen(s);

    std::string result;
    result.reserve(len);    // <--- preallocate result
    for (auto s : {args...})  result += s;
    return result;
}

Використання:

std::string merged = concat("This ", "is ", "a ", "test!");

Найпростіший масив символів, інкапсульований у класі, який відстежує розмір масиву та кількість виділених байтів, є найшвидшим.

Хитрість полягає в тому, щоб зробити лише один великий розподіл на початку.

у

https://github.com/pedro-vicente/table-string

Орієнтири

Для Visual Studio 2015, збірка налагодження x86, істотне вдосконалення над C ++ std :: string.

| API                   | Seconds           
| ----------------------|----| 
| SDS                   | 19 |  
| std::string           | 11 |  
| std::string (reserve) | 9  |  
| table_str_t           | 1  |  

Ви можете спробувати це з резервацією пам’яті для кожного елемента:

namespace {
template<class C>
constexpr auto size(const C& c) -> decltype(c.size()) {
  return static_cast<std::size_t>(c.size());
}

constexpr std::size_t size(const char* string) {
  std::size_t size = 0;
  while (*(string + size) != '\0') {
    ++size;
  }
  return size;
}

template<class T, std::size_t N>
constexpr std::size_t size(const T (&)[N]) noexcept {
  return N;
}
}

template<typename... Args>
std::string concatStrings(Args&&... args) {
  auto s = (size(args) + ...);
  std::string result;
  result.reserve(s);
  return (result.append(std::forward<Args>(args)), ...);
}