std::string и std::string_view в C++: разница, производительность и безопасные паттерны
Запрос «string_view в C++: когда использовать и чем он лучше std::string» — один из самых частых у начинающих. Разобраться важно: от правильного выбора типа зависит и производительность, и безопасность кода. В этой статье мы сравним std::string и std::string_view, разберёмся с владением, временем жизни, покажем практичные примеры и типичные ошибки.
Ключевая идея: владение против представления
Из этого следует правило: если функция только читает строку, удобнее принимать std::string_view. Если нужно хранить, модифицировать или продлить жизнь данных — используйте std::string.
Создание и совместимость
std::string_view легко строится из строковых литералов, std::string и C‑строк:
#include <string>
#include <string_view>
void f(std::string_view sv);
int main() {
std::string s = "hello";
const char* c = "world";
f(s); // из std::string
f(c); // из C-строки
f("literal"); // из литерала
}
Обратное преобразование (view → string) требует копирования:
std::string_view sv = "data";
std::string owned = std::string(sv); // копия, владение теперь у owned
Где string_view особенно полезен
1) Входные параметры без копий
#include <string_view>
#include <cctype>
// Подсчёт слов: разделитель — пробельный символ
size_t count_words(std::string_view text) {
size_t count = 0;
bool in_word = false;
for (unsigned char ch : text) {
if (std::isspace(ch)) {
in_word = false;
} else if (!in_word) {
in_word = true;
++count;
}
}
return count;
}
Функция принимает и std::string, и литералы, и C-строки без лишних копий.
2) Быстрый trim без аллокаций
#include <string_view>
#include <cctype>
std::string_view trim(std::string_view sv) {
auto is_space = [](unsigned char c){ return std::isspace(c); };
while (!sv.empty() && is_space(sv.front())) sv.remove_prefix(1);
while (!sv.empty() && is_space(sv.back())) sv.remove_suffix(1);
return sv; // всё ещё view на исходные данные
}
3) Лёгкий сплит по разделителю
#include <string_view>
#include <vector>
std::vector<std::string_view> split(std::string_view sv, char delim) {
std::vector<std::string_view> parts;
size_t start = 0;
while (true) {
size_t pos = sv.find(delim, start);
if (pos == std::string_view::npos) {
parts.push_back(sv.substr(start));
break;
}
parts.push_back(sv.substr(start, pos - start));
start = pos + 1;
}
return parts; // вектора view; копий строк нет
}
Важно: полученные подстроки живут не дольше исходных данных, на которые они ссылаются.
Опасные места и как их избежать
1) Возврат view на временные данные — ошибка
// ПЛОХО: возвращаем view на локальный std::string
std::string_view bad() {
std::string s = "temp";
return s; // висячая ссылка (dangling)
}
Правильно: вернуть std::string (владеющий) или принять буфер снаружи.
// Хорошо: возвращаем владение
std::string good() {
std::string s = "ok";
return s; // RVO/NRVO, без лишней копии
}
2) Долгое хранение string_view
std::string make()
{
std::string s = "hello";
return s;
}
std::string_view sv;
{
std::string tmp = make();
sv = tmp; // sv указывает внутрь tmp
} // tmp разрушен — sv теперь висячий
Решение: если нужно хранить — храните std::string или делайте копию:
std::string owned;
{
std::string tmp = make();
owned = tmp; // корректно
}
3) Реаллокиация ломает все view
std::string s = "abc";
std::string_view v = s; // указывает внутрь s
s += "def"; // возможна реаллокация буфера
// v может стать недействительным
Вывод: не храните string_view на строку, которую планируется изменять (push_back, append, resize и т.п.).
Производительность: когда реально быстрее
Поэтому в API для чтения данных используйте string_view. В местах, где нужны собственные данные или модификация — string.
Интероп с C‑API: c_str() и data()
extern "C" void c_api(const char*);
std::string s = "hello";
c_api(s.c_str()); // ок
std::string_view sv = "world";
// c_api(sv.data()); // может не содержать ' ' в конце — небезопасно
// Решение: скопировать
std::string tmp(sv);
c_api(tmp.c_str());
Практика: парсинг ключ=значение без копий
#include <string_view>
#include <optional>
#include <utility>
std::optional<std::pair<std::string_view, std::string_view>>
parse_kv(std::string_view sv) {
auto pos = sv.find('=');
if (pos == std::string_view::npos) return std::nullopt;
auto key = sv.substr(0, pos);
auto val = sv.substr(pos + 1);
return std::make_pair(trim(key), trim(val));
}
Функция возвращает пары view; при необходимости сохранения значений — скопируйте их в std::string.
Частые вопросы
Можно ли модифицировать через string_view? Нет. Это read-only представление. Если нужно изменить — используйте string или span к изменяемому буферу.
Как быть с Unicode? std::string — это просто байты. Операции size(), substr() работают по байтам, а не по кодовым точкам. Для Unicode учитывайте кодировку (UTF‑8) и используйте специализированные библиотеки.
Рекомендации и паттерны
Хотите системно прокачать основы C++ (типы, ссылки, строки, память, ООП) и практику на проектах? Загляните в пошаговый курс «C++ с Нуля до Гуру» — от синтаксиса к реальным задачам.
Итоги
std::string — для владения и модификации. std::string_view — для чтения без копий. Соблюдайте правила времени жизни и не храните view «на будущее». С этими принципами ваш код станет одновременно быстрее и надёжнее.
