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

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

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

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

⏱ --:--

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

Вопрос 1 из 20

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

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

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

Вопрос 2 из 20

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

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

Проверить результат на NULL Вызвать free Вызвать 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);
}

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

Вопрос 5 из 20

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

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

Вопрос 6 из 20

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

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

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

Вопрос 7 из 20

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

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

`p=realloc(p,new_count*sizeof *p); if(!p){ /* освободить старый p */ }`free(p); p=realloc(p,n); `int *tmp=realloc(p,new_count); if(tmp) memcpy(tmp,p,new_count);`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;

`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);

Вопрос 8 из 20

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

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

Вопрос 9 из 20

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

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

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

Вопрос 10 из 20

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

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

Вопрос 11 из 20

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

int *p=NULL;
free(p);

Разрешено только в `main`, где после вызова не остаётся вызывающего кода Допустимо только один раз за всё время работы процесса Нет: `free` требует адрес ранее выделенного ненулевого блока Да: стандарт определяет `free(NULL)` как операцию без эффекта Разрешено лишь тогда, когда `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 Сначала free(obj->name), затем free(obj) Сначала объект, потом name через уже освобождённое поле Только obj Только name

Вопрос 14 из 20

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

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

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

Вопрос 15 из 20

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

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

Вопрос 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, документацией и обнулением источника после успешной передачи Передачу можно обозначить только препроцессорным макросом `MOVE` Достаточно привести адрес к `void *`, и владение перейдёт автоматически Выразить передачу владения в C невозможно даже соглашением интерфейса Нужно удалить проверки `NULL`, чтобы источник больше не использовался

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

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

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

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