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

Основы указателей

Тест проверяет адреса и разыменование без магии: нулевые и висячие указатели, const, void*, доступ к структурам и ситуации, где нужен двойной указатель для изменения состояния вызывающей стороны.

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

⏱ --:--

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

Вопрос 1 из 20

Как изменится x после записи через указатель p?

#include <stdio.h>

int main(void) {
    int x = 3;
    int *p = &x;
    *p = 7;
    printf("%d\n", x);
}

Поведение не определено Адрес x 3 7 10

Вопрос 2 из 20

Каков тип выражения `&p`, если p объявлен как `int *p`?

int *p = 0;
/* тип выражения &p */

int ** void * size_t int int *

Вопрос 3 из 20

Какое равенство гарантировано после `int *p = &x;`?

int x = 42;
int *p = &x;

sizeof p == sizeof x p == &x &p == &x p == x *p == &x

Вопрос 4 из 20

Почему выражение `*&x` допустимо и чему оно соответствует?

int x = 5;
*&x = 9;

После `&x` тип объекта `x` навсегда меняется на указательный Выражение даёт числовое значение адреса `x`, не обращаясь к самому объекту Оператор `*` освобождает объект, ранее переданный оператору `&` Комбинация `*&` запрещена, потому что два унарных оператора нельзя ставить подряд `&x` создаёт указатель на `x`, а разыменование этого указателя снова обозначает `x`

Вопрос 5 из 20

Что нужно доказать перед `*p = value`?

Достаточно доказать, что числовое значение `p` не равно нулю Нужно лишь проверить, что числовой адрес меньше `INT_MAX` Достаточно, чтобы присваиваемое `value` было положительным и помещалось в `int` Доступ корректен только тогда, когда `p` получен непосредственно из `malloc` `p` обозначает живой записываемый объект совместимого типа с правильным выравниванием

Вопрос 6 из 20

Что делает проверка `if (p)`?

if (p) { use(*p); }

Проверяет, что указатель находится внутри доступного адресного пространства процесса Выполняет пробное разыменование без чтения значения объекта Проверяет, что объект по адресу инициализирован и имеет ожидаемый эффективный тип Проверяет, что адрес получен именно от `malloc` и ещё не передан в `free` Проверяет, что p не является нулевым указателем

Вопрос 7 из 20

Можно ли разыменовать нулевой указатель?

int *p = NULL;
printf("%d\n", *p);

Только один раз Да, если тип int* Только в main Да, получится 0 Нет; это неопределённое поведение

Вопрос 8 из 20

Как лучше выразить необязательный выходной параметр?

int parse(const char *s, size_t *consumed) {
    if (consumed != NULL) *consumed = n;
    return value;
}

Всегда разыменовывать `out`, считая его обязательным Возвращать через `out` адрес локального объекта функции Сохранять указатель `out` в глобальной переменной до следующего вызова При `out != NULL` записывать результат; `NULL` означает отказ от него Использовать значение `(size_t *)-1` вместо NULL

Вопрос 9 из 20

Что гарантирует присваивание `int *p = 0;`?

int *p = 0;

Немедленное исключение Создание нулевого указателя типа int* Адрес с битами обязательно равными нулю Выделение одного int Адрес первого байта процесса

Вопрос 10 из 20

Почему проверка NULL после free не обнаруживает обращение после освобождения памяти автоматически?

free(p);
if (p != NULL) {
    use(*p);
}

`free` всегда присваивает `NULL` переданной переменной, поэтому проверка избыточна `free` не меняет копии адреса: ненулевой `p` уже не обозначает живой объект Освобождённый адрес по определению сравнивается равным `NULL` После `free` чтение через старый адрес разрешено до следующего выделения памяти Проверка `p != NULL` после `free` не компилируется в языке C

Вопрос 11 из 20

Как обратиться к полю value через указатель p на struct item?

struct item { int value; };
struct item x = {7};
struct item *p = &x;

p->value p.value *p.value p::value &p.value

Вопрос 12 из 20

Какое преобразование выполняется неявно и обратно без потери значения для указателя на объект?

int x;
void *v = &x;
int *p = v;

const int* ↔ int* без ограничений Указатель на функцию ↔ void* по стандарту C Указатель ↔ int всегда int* ↔ double* Указатель на объект ↔ void*

Вопрос 13 из 20

Что запрещает тип `const int *p`?

const int *p = &x;

Изменять сам p Изменять обозначаемый int через p Читать *p Передавать p в функцию чтения Сравнивать p с NULL

Вопрос 14 из 20

Почему приведение `double *d = (double *)&x;` с последующим чтением опасно?

int x = 0x3f800000;
double *d = (double *)&x;
printf("%f\n", *d);

После приведения сама переменная `x` меняет объявленный тип на `double` Приведение меняет лишь тип указателя: возможны недостаточный размер, неверное выравнивание и недопустимый тип доступа Явное приведение создаёт новый объект `double` поверх памяти `x`, поэтому чтение безопасно Указатели на разные объектные типы нельзя даже явно приводить друг к другу Опасность только в том, что стандарт требует `double` быть меньше `int`

Вопрос 15 из 20

Какой параметр лучше для функции, которая только читает объект config?

void *cfg без контракта const struct config *cfg struct config *cfg struct config cfg[] без длины int cfg

Вопрос 16 из 20

Какое значение получит `x` после показанного вызова `inc(&x)`?

#include <stdio.h>

static void inc(int *p) { ++*p; }

int main(void) {
    int x = 5;
    inc(&x);
    printf("%d\n", x);
}

Адрес x 5 Поведение не определено 6 1

Вопрос 17 из 20

Почему функция `reset(int *p) { p = NULL; }` не обнуляет указатель вызывающего кода?

void reset(int *p) { p = NULL; }

p — локальная копия указателя; меняется только копия Изменение станет видно вызывающему только после возврата нового значения из `reset` Оператор присваивания не меняет указатели; для этого существует отдельная операция `free` Присваивание `NULL` параметру запрещено, пока указатель не был освобождён Указатель вызывающего кода хранится в неизменяемой области, а параметр — в стеке

Вопрос 18 из 20

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

int *p = NULL;
size_t n = checked_count();
if (make_buffer(&p, n) != 0) {
    handle_allocation_error();
}

`int make_buffer(int **out,size_t n){ int *p=malloc(n*sizeof *p); if(!p)return -1; *out=p; return 0; }`

int make(int **out) {
    int *p = malloc(sizeof *p);
    if (!p) return 0;
    *out = p;
    return 1;
}

`int make_buffer(int **out,size_t n){ int *tmp=malloc(n*sizeof *tmp); return tmp?0:-1; }`int make(int *p) { p = malloc(sizeof *p); return p != NULL; } `int make_buffer(int ***out,size_t n){ **out=malloc(n*sizeof ***out); return **out?0:-1; }`int *make(int **out) { return &out; } `int make_buffer(int **out,size_t n){ int *p=malloc(n*sizeof *p); out=&p; return p?0:-1; }`void make(void) { int *p = NULL; } `int make_buffer(int **out,size_t n){ int local[128]; *out=local; return n<=128?0:-1; }`int make(int p) { return malloc(p); }

Вопрос 19 из 20

Функция принимает `const char **out`. Можно ли передать ей `char **` без приведения?

void provide(const char **out);
char *p;
provide(&p); /* диагностируется */

Можно, если текущая строка пуста и функция не записывает символы сразу Можно только на платформе, где `char *` и `const char *` имеют одинаковый размер Да: квалификатор `const` безопасно добавляется на любом уровне вложенности указателя Нет: через `const char **` можно было бы подменить `char *` указателем на неизменяемые данные Да: при передаче параметров C всегда полностью игнорирует квалификаторы типа

Вопрос 20 из 20

Какой контракт наиболее устойчив для функции создания объекта?

Принять `T **out`, держать `*out == NULL` до успешной передачи владения Передать владение всем получившим адрес модулям и разрешить каждому освобождать объект после своего последнего использования Разрешить функции менять `*out` до завершения всех шагов, а при ошибке документировать только код возврата Хранить новый объект во внутренней глобальной переменной и возвращать вызывающему указатель на неё Собрать объект в локальной переменной и вернуть её адрес после успешной инициализации

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

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

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

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