Наскільки саме std :: string_view швидше, ніж const std :: string &?

std::string_viewзробив це на C ++ 17, і його широко рекомендується використовувати замість const std::string&.

Однією з причин є продуктивність.

Чи може хтось пояснити, наскільки саме std::string_view / буде швидше, ніж const std::string&при використанні як тип параметра? (припустимо, що копії в назві не зроблено)

std::string_view швидше в кількох випадках.

По-перше, std::string const&вимагає, щоб дані знаходилися в a std::string, а не в необробленому масиві C, char const*повертається API API, std::vector<char>виробляється деяким механізмом десеріалізації тощо. Перетворення формату, що ухиляється, дозволяє уникнути копіювання байтів, і (якщо рядок довший ніж SBO¹ для конкретної std::stringреалізації) уникає виділення пам'яті.

void foo( std::string_view bob ) {
  std::cout << bob << "\n";
}
int main(int argc, char const*const* argv) {
  foo( "This is a string long enough to avoid the std::string SBO" );
  if (argc > 1)
    foo( argv[1] );
}

Ніяких розподілів у string_viewсправі не робиться , але було б, якби fooвзяли std::string const&замість а string_view.

Друга справді велика причина - це те, що вона дозволяє працювати з підрядками без копії. Припустимо, ви розбираєте 2-гігабайтний json рядок (!) ². Якщо проаналізувати його std::string, кожен такий вузол розбору, де вони зберігають ім'я або значення вузла, копіює вихідні дані з рядка 2 ГБ в локальний вузол.

Натомість, якщо розібрати їх до std::string_views, вузли посилаються на вихідні дані. Це може заощадити мільйони асигнувань та зменшити вдвічі менше пам'яті під час розбору.

Швидкість, яку ви можете отримати, просто смішна.

Це надзвичайний випадок, але інші випадки "отримати підрядку та працювати з ним" також можуть генерувати гідні прискорення string_view.

Важливою частиною рішення є те, що ви втрачаєте, використовуючи std::string_view. Це не багато, але це щось.

Ви втрачаєте неявне припинення нуля, і це стосується цього. Отже, якщо однаковий рядок буде передано 3 функціям, всі з яких потребують нульового термінатора, перетворення на std::stringодин раз може бути розумним. Таким чином, якщо, як відомо, ваш код потребує нульового термінатора, і ви не очікуєте, що рядки, подані з буферів, створених у стилі C, або подібного, можливо, візьміть a std::string const&. В іншому випадку візьміть std::string_view.

Якщо у вас std::string_viewбув прапор, який зазначав, що він був скасований на нуль (або щось більш фантазійне), він би видалив навіть цю останню причину для використання std::string const&.

Відомий випадок, коли прийом « std::stringне» const&є оптимальним за «a» std::string_view. Якщо після виклику вам потрібно володіти копією рядка на невизначений термін, отримання побічної вартості є ефективним. Ви або будете знаходитись у корпусі SBO (і жодних виділень, лише декілька копій символів для його дублювання), або ви зможете перемістити виділений купою буфер в локальний std::string. Маючи дві перевантаження std::string&&і std::string_viewможе бути швидше, але лише незначно, і це спричинить скромний розрив коду (що може коштувати вам усіх швидкостей).

¹ Невелика оптимізація буфера

² Фактичне використання.

Один із способів того, що string_view покращує продуктивність, це те, що він дозволяє легко видаляти префікси та суфікси. Під кришкою string_view може просто додати розмір префікса до вказівника до якогось буферного рядка або відняти розмір суфікса з лічильника байтів, це зазвичай швидко. std :: string з іншого боку має копіювати свої байти, коли ви робите щось на кшталт substr (таким чином ви отримуєте новий рядок, який володіє його буфером, але в багатьох випадках ви просто хочете отримати частину оригінальної рядки без копіювання). Приклад:

std::string str{"foobar"};
auto bar = str.substr(3);
assert(bar == "bar");

З std :: string_view:

std::string str{"foobar"};
std::string_view bar{str.c_str(), str.size()};
bar.remove_prefix(3);
assert(bar == "bar");

Оновлення:

Я написав дуже простий орієнтир, щоб додати кілька реальних цифр. Я використав дивовижну бібліотеку бенчмарків google . Орієнтовними функціями є:

string remove_prefix(const string &str) {
  return str.substr(3);
}
string_view remove_prefix(string_view str) {
  str.remove_prefix(3);
  return str;
}
static void BM_remove_prefix_string(benchmark::State& state) {                
  std::string example{"asfaghdfgsghasfasg3423rfgasdg"};
  while (state.KeepRunning()) {
    auto res = remove_prefix(example);
    // auto res = remove_prefix(string_view(example)); for string_view
    if (res != "aghdfgsghasfasg3423rfgasdg") {
      throw std::runtime_error("bad op");
    }
  }
}
// BM_remove_prefix_string_view is similar, I skipped it to keep the post short

Результати

(x86_64 linux, gcc 6.2, " -O3 -DNDEBUG"):

Benchmark                             Time           CPU Iterations
-------------------------------------------------------------------
BM_remove_prefix_string              90 ns         90 ns    7740626
BM_remove_prefix_string_view          6 ns          6 ns  120468514

Є дві основні причини:

• string_view є фрагментом у існуючому буфері, він не потребує виділення пам'яті
• string_view передається за значенням, а не за посиланням

Переваги наявності шматочка є декількома:

• ви можете використовувати його з char const*або char[]без виділення нового буфера
• ви можете взяти кілька фрагментів і підпунктів у існуючий буфер, не виділяючи їх
• підрядка - O (1), а не O (N)
• ...

Покращення та стабільність роботи у всьому світі.

Передача за значенням також має переваги перед проходженням посилань, тому що їх псевдонім.

Зокрема, коли у вас є std::string const&параметр, немає гарантії, що посилання рядка не буде змінено. В результаті компілятор повинен повторно вибирати вміст рядка після кожного виклику в непрозорий метод (вказівник на дані, довжину, ...).

З іншого боку, при передачі string_viewзначення за значенням компілятор може статично визначити, що жоден інший код не може змінювати покажчики довжини та даних, які зараз знаходяться на стеку (або в регістрах). Як результат, він може «кешувати» їх у всіх викликах функцій.

Одне, що можна зробити, - це уникати побудови std::stringоб'єкта у випадку неявного перетворення з нульового завершеного рядка:

void foo(const std::string& s);

...

foo("hello, world!"); // std::string object created, possible dynamic allocation.
char msg[] = "good morning!";
foo(msg); // std::string object created, possible dynamic allocation.

std::string_viewв основному просто обгортка навколо const char*. А проходження const char*означає, що в системі буде один менший покажчик порівняно з проходженням const string*(або const string&), тому що string*передбачає щось на кшталт:

string* -> char* -> char[]
           |   string    |

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

ps Одним з істотних відмінностей між std::string_viewі const char*, тим не менш, є те, що строки перегляду строків не повинні бути завершені на нуль (вони мають вбудований розмір), і це дозволяє випадковим на місці сплайсингу довших рядків.