C++ C++ · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Средний ·

string_view, span и невладеющие представления

Тест проверяет интерфейсы без копирования, где главная цена — обязанность доказать время жизни. Вопросы разбирают строки без завершающего нуля, span фиксированной длины, временные контейнеры и ошибки, когда лёгкое представление сохраняют дольше владельца.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. В тесте 25 вопросов, время — 70 минут. Во многих заданиях недостаточно узнать конструкцию: проследите порядок вычислений, время жизни объектов, владение ресурсами и условия, при которых решение остаётся корректным. После завершения откроются правильные ответы, объяснения, общий результат и тематические шкалы.

Вопрос 1 из 25

Что хранит std::string_view?

Только завершающий ноль Копию каждого символа в стеке Указатель, длину и контрольный блок, который продлевает жизнь исходной строки Указатель и длину без владения буфером Собственную std::string

Вопрос 2 из 25

Гарантирует ли `view.data()` завершающий ноль сразу после view.size() символов?

std::string text = "header:value";
std::string_view view{text.data(), 6}; // "header"

const char* p = view.data();
std::printf("%s", p); // печать не ограничена view.size()

Нет Только в C++23 запрещено Да, потому что data возвращает char* Только если view пуст Да, всегда

Вопрос 3 из 25

Почему `printf("%s", view.data())` может вывести лишние символы?

std::string s = "hello-world";
std::string_view view{s.data(), 5};
printf("%s", view.data());

string_view хранит UTF-16 data() создаёт временную нуль-терминированную копию подстроки для C API Проблема только при пустом view printf получает длину string_view из типа аргумента и ограничивает чтение view.size() `printf` читает до нуля, а view может быть префиксом

Вопрос 4 из 25

Что делает `view.remove_prefix(2)`?

std::string_view view = "hello world";
view.remove_prefix(2);

std::cout << view; // "llo world"; исходная строка не меняется

Удаляет два символа из исходной string Создаёт новую строку в куче Освобождает память Сдвигает все символы массива Сдвигает начало view и уменьшает длину

Вопрос 5 из 25

Почему `"abc"sv` удобно?

using namespace std::string_view_literals;

auto command = "quit"sv;
static_assert(std::is_same_v<decltype(command), std::string_view>);
parse(command);

Литерал создаёт string_view с известной длиной без поиска завершающего нуля через strlen Он создаёт изменяемую std::string и переносит её буфер в представление Оператор доступен только во время выполнения и не образует константное выражение К исходному литералу добавляются два нулевых символа: один для string_view, другой для C API Все такие литералы получают отдельный разделяемый владеющий буфер

Вопрос 6 из 25

Что выражает параметр `std::span<const int> values`?

int values[]{3, 5, 8, 13};

void print(std::span<const int> input) {
    for (int value : input) std::cout << value << ' ';
}

print(values);

Функция принимает именно `std::vector<int>` и получает совместное владение им Функция видит невладеющий непрерывный диапазон int только для чтения Функция получает ссылку только на первый int, не зная длины диапазона Функция работает с произвольным диапазоном, включая связные списки Функция принимает динамический массив и обязана удалить его после использования

Вопрос 7 из 25

Что означает `std::span<int, 4>`?

void transform_block(std::span<int, 4> block) {
    static_assert(decltype(block)::extent == 4);
    std::ranges::reverse(block);
}

std::array<int, 4> data{1,2,3,4};
transform_block(data);

Extent равен четырём и является частью типа span Число 4 не влияет на тип и служит только подсказкой документации Каждый элемент span имеет размер ровно четыре байта независимо от sizeof(int) Span владеет встроенным массивом из четырёх int и копирует данные при создании Динамический span может увеличиваться до четырёх элементов при первом обращении

Вопрос 8 из 25

Можно ли построить span из std::list<int>?

Нет, элементы list не хранятся непрерывно Да, если list отсортирован Да, span скопирует элементы Да, если список не меняется и все его узлы содержат один и тот же тип Да, любой range подходит

Вопрос 9 из 25

Что возвращает `s.subspan(2, 3)`?

std::array<int, 8> values{0,1,2,3,4,5,6,7};
std::span<int> all = values;
auto middle = all.subspan(2, 3);

for (int x : middle) std::cout << x;

Удалённый из исходного span диапазон, после чего s становится короче Один указатель на второй элемент без сведений о длине Владеющий vector из элементов с индексами 2, 3, 4, 5 и 6 Ссылку только на элемент с индексом 3 Невладеющий span длиной три, начинающийся с элемента с индексом 2

Вопрос 10 из 25

Какая проблема остаётся у operator[] span?

Оператор определён только у span<const T>, но не у изменяемого span<T> Индекс интерпретируется относительно конца и потому должен быть отрицательным Он обязан бросать out_of_range при любой ошибке индекса Каждое обращение создаёт копию всего диапазона для безопасного чтения Оператор не обязан выполнять проверку границ перед доступом

Вопрос 11 из 25

Почему возвращаемый view висячий?

std::string_view make_name(){
    std::string name = "Ada";
    return name;
}

std::string живёт до конца программы return копирует только один символ Ссылается на уничтоженную локальную string string_view нельзя возвращать При возврате string_view принимает владение буфером локальной std::string

Вопрос 12 из 25

Что может сделать span на vector недействительным?

Копирование самого span Перераспределение vector Копирование vector в другую переменную при сохранении исходного объекта без изменений Перестановка элементов исходного vector через std::sort без перераспределения буфера Изменение значений элементов vector без изменения его размера и capacity

Вопрос 13 из 25

Безопасен ли `std::string_view v = std::string("abc");` после точки с запятой?

std::string_view view = std::string("abc");

// Временная std::string уничтожена в конце полной инструкции.
std::cout << view;

Код не компилируется и потому безопасен Да, view продлевает жизнь временного Да, литерал копируется в v Нет, временная string уничтожена, v висячий Только при оптимизации unsafe

Вопрос 14 из 25

Может ли перемещение std::string инвалидировать view на её данные?

Представление отслеживает объект std::string и обновляет адрес после его перемещения Нет, move всегда сохраняет адрес Только если строка пустая Перемещение string запрещено Да, старый адрес после move не гарантирован

Вопрос 15 из 25

Когда span на локальный массив остаётся безопасен?

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

Вопрос 16 из 25

Какая сигнатура уместна для функции, которая только разбирает имя и не сохраняет его?

ParsedName parse_name(std::string_view text) {
    auto separator = text.find(':');
    return {text.substr(0, separator), text.substr(separator + 1)};
}
// Безопасность возврата зависит от того, владеет ли ParsedName строками.

`Result parse(std::string* text)` с неясным null `Result parse(std::string_view text)` `Result parse(std::shared_ptr<std::string>)` `Result parse(char* text)` без длины `Result parse(std::string&&)` обязательно

Вопрос 17 из 25

Какая сигнатура безопаснее для функции, сохраняющей имя внутри объекта?

Принять string по значению и сохранить Сохранить переданный string_view без требования к владельцу Сохранить span<char> на параметр Принять const char* и хранить адрес Принять ссылку на локальную строку

Вопрос 18 из 25

Когда span лучше пары `(T* data, size_t size)`?

void decode(std::span<const std::byte> packet);

std::array<std::byte, 128> buffer{};
decode(buffer);
decode(std::span{buffer}.first(32));

Только для виртуальных функций Как единый тип с begin/end и subspan Когда функция должна удалить data Никогда: span копирует все элементы, тогда как пара ptr,size остаётся невладеющей Только если размер равен нулю

Вопрос 19 из 25

Что лучше вернуть из функции, которая формирует новый текст?

std::string make_label(const User& user) {
    std::string result = user.first_name();
    result += ' ';
    result += user.last_name();
    return result;
}

`std::string_view` на локальный буфер `std::string` `const char*` на локальный массив `std::span<char>` на временный vector `char&` на первый символ

Вопрос 20 из 25

Можно ли принимать `std::span<const std::byte>` как двоичный пакет?

Header parse_header(std::span<const std::byte> packet) {
    if (packet.size() < sizeof(WireHeader))
        throw ParseError{"short packet"};
    return decode_header(packet.first(sizeof(WireHeader)));
}

`std::byte` автоматически учитывает endian и декодирует поля сетевого протокола Нет: span разрешён только для арифметического типа int Да: это типизированная невладеющая граница последовательности сырых байтов Принимающая функция становится владельцем и обязана освободить буфер Только если пакет завершается нулевым байтом, как C-строка

Вопрос 21 из 25

Какой тест обнаружит ошибочное использование `strlen(view.data())`?

std::array<char, 4> raw{'A', 'B', 'C', 'D'};
std::string_view view(raw.data(), raw.size());

// Тест запускает функцию, которая ошибочно делает strlen(view.data()).
EXPECT_EQ(parse_length(view), 4);

Подстрока буфера с иной длиной Только литерал "abc" Копирование view Пустой owning string Сравнение sizeof(view)

Вопрос 22 из 25

Что может обнаружить AddressSanitizer для span?

Логическую неверность значений, если все обращения остаются в живом буфере Фактический use-after-free или обращение через span после перераспределения исходного буфера Любую ошибку индекса, включая случаи, когда вычисленный адрес не выходит за выделенный объект Отсутствие текстового описания срока жизни в документации API Слишком широкий публичный интерфейс, даже если память используется корректно

Вопрос 23 из 25

Какие границы нужно тестировать для `first(n)` у span?

std::array<int, 3> values{1,2,3};
std::span<int> span = values;

auto empty = span.first(0);
auto full  = span.first(span.size());
// span.first(span.size() + 1) нарушает предусловие.

Только отрицательные n, хотя size_t беззнаковый Только n=1 Только большой буфер Ни одной `0`, `size`, `n > size`

Вопрос 24 из 25

Как документировать поле string_view в классе?

Скрыть поле без контракта Считать, что const продлевает жизнь Указать владельца и гарантию его времени жизни Написать только “быстрая строка” Указать только, что представление не владеет памятью, не называя владельца и срок его жизни

Вопрос 25 из 25

Какой тест сравнивает корректность API со span и старого API `ptr,size`?

Result old_parse(const std::byte* data, std::size_t size);
Result new_parse(std::span<const std::byte> data);

for (const auto& sample : corpus) {
    EXPECT_EQ(old_parse(sample.data(), sample.size()), new_parse(sample));
}

Сравнить только имена функций Измерить размер бинарника Сравнить оба API на тех же диапазонах и ошибках Вызвать с nullptr и ненулевой длиной без контракта Проверить только один указатель

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу