C C · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Лёгкий ·

Динамическая память

Тест проверяет полный жизненный цикл выделенной памяти: безопасный расчёт размера, отказ realloc, повторное освобождение памяти, составную очистку и договорённости о владении, без которых отдельные вызовы malloc/free не образуют надёжную программу.

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

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 20 вопросов отведено 55 минут. Код читайте построчно: часть заданий проверяет вывод, часть — поиск дефекта, переносимость и безопасное исправление. После завершения откроются объяснения и профиль по 4 темам.

Вопрос 1 из 20

Какой вызов выделяет массив count элементов типа *p без повторения имени типа?

int *p = /* ... */;

`malloc(sizeof p)` — размер массива выводится из типа указателя `malloc(sizeof count)` — число элементов уже учтено в count `malloc(count)` — размер элемента компилятор добавит автоматически `calloc(sizeof p, 1)` — первый аргумент задаёт число элементов `malloc(count * sizeof *p)` после проверки умножения

Вопрос 2 из 20

Что нужно сделать сразу после malloc до разыменования?

struct node *n=malloc(sizeof *n);
/* следующий шаг */

Вызвать free Проверить результат на NULL Записать за конец блока Вызвать strlen Привести к int* обязательно

Вопрос 3 из 20

Чем calloc отличается по инициализации?

Не может отказать Создаёт все значения как C-нулевые указатели на любой реализации без оговорки Заполняет выделенную область нулевыми байтами Заполняет единицами Заполняет только первые `sizeof(void *)` байтов нулями, остальные оставляет неизменными

Вопрос 4 из 20

Как корректно проверить умножение count*size?

void *allocate_array(size_t count, size_t size) {
    /* Сначала нужно проверить, представимо ли count * size. */
    return malloc(count * size);
}

size==0 || count<=SIZE_MAX/size count+size>count count*size<=SIZE_MAX после умножения Привести результат к unsigned Проверка не нужна

Вопрос 5 из 20

Что гарантирует malloc(0)?

Вызов с нулём обязан немедленно завершить программу Всегда возвращается уникальный байт, пригодный для чтения и записи Стандарт требует всегда возвращать `NULL` Функция выделяет место как минимум для одного объекта `int` Допустим `NULL` либо освобождаемое значение; разыменовывать его как ненулевой объект нельзя

Вопрос 6 из 20

Почему `p = realloc(p,new_size)` опасно?

p=realloc(p,new_size);
if(!p) return ERROR;

Прямое присваивание опасно лишь для указателей не типа `char *` `realloc` всегда возвращает прежний адрес, поэтому присваивание не влияет на владение При отказе `NULL` затрёт единственную ссылку, хотя прежний блок останется выделенным Перед `realloc` требуется явное приведение результата, иначе старый блок освобождается `realloc` умеет только увеличивать блок и отклоняет уменьшение

Вопрос 7 из 20

Какой вариант изменения размера сохраняет исходный блок, если `realloc` вернёт `NULL`?

int *p = malloc(old_count * sizeof *p);
/* new_count * sizeof *p заранее проверено на переполнение */

`int *tmp=realloc(p,new_count); if(tmp) memcpy(tmp,p,new_count);`realloc(&p,n); `free(p); p=realloc(p,new_count*sizeof *p);`p=NULL; realloc(p,n); `int *tmp=realloc(p,new_count*sizeof *p); free(tmp); p=tmp;`if(realloc(p,n)) free(p); `p=realloc(p,new_count*sizeof *p); if(!p){ /* освободить старый p */ }`free(p); p=realloc(p,n); `int *tmp=realloc(p,new_count*sizeof *p); if(!tmp){ /* p жив */ } else { p=tmp; }`

void *tmp=realloc(p,n);
if(!tmp){ /* p всё ещё действителен */ return 0;}
p=tmp;

Вопрос 8 из 20

Можно ли использовать старые внутренние указатели после успешного realloc?

Нет: после перемещения блока все указатели на прежние элементы недействительны Можно, когда числовое значение основного указателя визуально не изменилось Можно продолжать использовать только указатель на первый элемент старого блока Можно, если новый размер больше прежнего Да: `realloc` сохраняет действительность всех внутренних адресов независимо от перемещения

Вопрос 9 из 20

Что гарантируется для содержимого при успешном увеличении блока через `realloc`?

int *q = realloc(p, new_count * sizeof *p);
/* рассматривается ветвь q != NULL; размер заранее проверен */

После увеличения весь блок гарантированно заполняется нулями Содержимое сохраняется лишь при возврате того же числового адреса Элементы автоматически переставляются по возрастанию адресов Сохраняется только последний байт прежнего блока Сохраняется общий префикс старого и нового размеров; добавленная область не инициализирована

Вопрос 10 из 20

Как лучше обработать запрос capacity=0 переносимо?

Сохранить прежний указатель и разрешить один элемент, чтобы нулевая вместимость не требовала отдельного состояния Освободить `p` и обнулить указатель, размер и вместимость Преобразовать ноль в `SIZE_MAX`, полагаясь на гарантированный отказ выделения как сигнал пустого контейнера Привести указатель к целому и записать ноль в это целое, не меняя состояние владельца Всегда вызывать `realloc(p, 0)` и трактовать любой ненулевой результат как новый буфер нулевой вместимости

Вопрос 11 из 20

Допустим ли `free(NULL)`?

int *p=NULL;
free(p);

Да: стандарт определяет `free(NULL)` как операцию без эффекта Нет: `free` требует адрес ранее выделенного ненулевого блока Разрешено только в `main`, где после вызова не остаётся вызывающего кода Разрешено лишь тогда, когда `NULL` получен непосредственно из `malloc(0)` Допустимо только один раз за всё время работы процесса

Вопрос 12 из 20

Какое утверждение о `free` неверно?

free получает адрес, возвращённый аллокатором После free нельзя читать объект Внутренние ресурсы нужно освободить отдельно Повторный free того же блока — неопределённое поведение free автоматически обнуляет все копии указателя

Вопрос 13 из 20

В каком порядке уничтожать структуру с `char *name` и самим объектом?

void user_destroy(struct user *u){
 if(!u)return;
 free(u->name);
 free(u);
}

Порядок не важен даже при чтении поля после free Только name Только obj Сначала free(obj->name), затем free(obj) Сначала объект, потом name через уже освобождённое поле

Вопрос 14 из 20

Почему `p=NULL` после free не решает проблему полностью?

int *q=p;
free(p); p=NULL;
printf("%d",*q);

Блок снова выделяется free отменяется Компилятор удаляет строку NULL нельзя присваивать Другие копии адреса остаются висячими

Вопрос 15 из 20

Какой санитайзер компилятора лучше всего поймает обращение после освобождения памяти в воспроизводимом тесте?

ThreadSanitizer, предназначенный для гонок данных MemorySanitizer, ориентированный на чтение неинициализированных значений LeakSanitizer, сообщающий о неосвобождённых блоках UndefinedBehaviorSanitizer без проверки адресов освобождённой кучи AddressSanitizer в тестовой сборке с воспроизводимым входом

Вопрос 16 из 20

Что означает borrowed pointer?

Заимствованный указатель по определению всегда равен `NULL` Передача такого указателя означает создание глубокой копии объекта Получатель временно пользуется объектом, но не получает право его освобождать Получатель обязан вызвать `free` сразу после первого использования Любой указатель на стек является безопасно заимствованным без ограничения срока

Вопрос 17 из 20

Функция принимает владение buf даже при ошибке. Что важно?

int queue_push(struct queue *q, void *owned_item);

Контракт должен требовать, чтобы и функция, и вызывающая сторона освобождали один и тот же буфер Достаточно переименовать параметр: имя автоматически задаст момент передачи владения Одно и то же правило владения должно соблюдаться на успехе, отказе и при частично выполненной операции Семантику владения лучше не документировать, чтобы реализация могла менять её между версиями На успехе функция должна освобождать буфер, а на ошибке иногда оставлять решение вызывающему коду

Вопрос 18 из 20

Какой шаблон упрощает очистку при нескольких шагах создания?

resource *r=NULL; file *f=NULL;
/* шаги */
cleanup:
 close_file(f); destroy(r);

Повторять `malloc` в бесконечном цикле до успешного результата Инициализировать ресурсы нулями и вести одну ветвь очистки в обратном порядке Возвращаться из каждой ветви сразу, не освобождая уже созданные ресурсы Хранить все временные указатели в глобальных переменных Игнорировать промежуточные отказы и проверять только последний шаг

Вопрос 19 из 20

Кто освобождает строку, возвращённую как `const char *` на внутренний буфер объекта?

Функция `printf` освобождает внутренний буфер после вывода Никто: `const` означает бессрочное существование памяти Компилятор освобождает строку после последнего чтения Обычно владелец объекта; вызывающий лишь заимствует адрес в рамках указанного срока Всегда вызывающий, потому что любой возвращённый указатель передаёт владение

Вопрос 20 из 20

Как сделать передачу владения видимой в коде C?

Явным API, документацией и обнулением источника после успешной передачи Достаточно привести адрес к `void *`, и владение перейдёт автоматически Выразить передачу владения в C невозможно даже соглашением интерфейса Нужно удалить проверки `NULL`, чтобы источник больше не использовался Передачу можно обозначить только препроцессорным макросом `MOVE`

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

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

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

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