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()

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

Вопрос 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 `printf` читает до нуля, а view может быть префиксом Проблема только при пустом view printf получает длину string_view из типа аргумента и ограничивает чтение view.size()

Вопрос 4 из 25

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

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

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

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

Вопрос 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);

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

Вопрос 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);

Функция получает ссылку только на первый int, не зная длины диапазона Функция принимает именно `std::vector<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);

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

Вопрос 8 из 25

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

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

Вопрос 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 становится короче Невладеющий span длиной три, начинающийся с элемента с индексом 2 Один указатель на второй элемент без сведений о длине Ссылку только на элемент с индексом 3 Владеющий vector из элементов с индексами 2, 3, 4, 5 и 6

Вопрос 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;
}

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

Вопрос 12 из 25

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

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

Вопрос 13 из 25

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

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

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

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

Вопрос 14 из 25

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

Перемещение string запрещено Только если строка пустая Нет, move всегда сохраняет адрес Представление отслеживает объект std::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_view text)` `Result parse(char* text)` без длины `Result parse(std::string&&)` обязательно `Result parse(std::shared_ptr<std::string>)` `Result parse(std::string* text)` с неясным null

Вопрос 17 из 25

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

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

Вопрос 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));

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

Вопрос 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::span<char>` на временный vector `char&` на первый символ `const char*` на локальный массив `std::string`

Вопрос 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)));
}

Нет: span разрешён только для арифметического типа int `std::byte` автоматически учитывает endian и декодирует поля сетевого протокола Да: это типизированная невладеющая граница последовательности сырых байтов Только если пакет завершается нулевым байтом, как 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);

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

Вопрос 22 из 25

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

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

Вопрос 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) нарушает предусловие.

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

Вопрос 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-страницу