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

const, volatile и restrict

Тест отделяет три часто смешиваемых механизма: `const` ограничивает изменение через выражение, `volatile` сохраняет особые обращения, а `restrict` задаёт обещание об отсутствии конфликтующих путей доступа. Задания проверяют последствия для интерфейсов, регистров устройств, потоков и оптимизатора.

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

⏱ --:--

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

Вопрос 1 из 25

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

const int *p=&x;

Сравнивать p Присваивать p другой адрес Читать *p Менять объект через *p Менять p

Вопрос 2 из 25

Что запрещает `int * const p = &x`?

int * const p=&x;

Менять x через p Передавать p функции Читать x Сравнивать *p Менять сам p после инициализации

Вопрос 3 из 25

Как объявить неизменяемый указатель на неизменяемый int?

int value = 7;
/* p нельзя переназначить и через p нельзя изменить value. */

int const *p const *int p int *const p const int *const p int const p*

Вопрос 4 из 25

Можно ли снять const кастом и записать в объект, изначально объявленный const?

const int x=3;
int *p=(int*)&x;
*p=4;

Можно в сборке без оптимизации, где компилятор сохраняет запись Нет: запись в объект, действительно объявленный `const`, имеет неопределённое поведение Можно для любого целого объекта, но не для структур Можно, если приведённый адрес не равен `NULL` Да: явное приведение полностью снимает ограничения исходного объекта

Вопрос 5 из 25

Почему параметр чтения лучше объявить `const struct cfg *`?

Такое объявление автоматически выделяет копию конфигурации Квалификатор продлевает время жизни объекта до конца программы Квалификатор документирует и проверяет отсутствие изменений через этот интерфейс `const` запрещает передавать функции нулевой указатель `const` гарантированно ускоряет чтение структуры

Вопрос 6 из 25

Для чего volatile уместен в системном C?

volatile unsigned *status=(volatile unsigned*)DEVICE_ADDR;
while((*status&READY)==0){}

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

Вопрос 7 из 25

Гарантирует ли volatile атомарность `counter++` между потоками?

volatile unsigned counter;
/* два потока выполняют counter++ */

Операция безопасна на одном физическом ядре, даже если потоки могут вытеснять друг друга Гарантия зависит от `-O2`: оптимизация превращает инкремент в атомарную машинную инструкцию Да: квалификатор `volatile` делает каждое чтение и запись неделимыми между потоками Атомарность появляется только для объектов типа `int`, но не для `unsigned` Нет: `counter++` включает чтение, вычисление и запись и остаётся гонкой без атомика или блокировки

Вопрос 8 из 25

Почему чтение volatile-регистра лучше не повторять без необходимости?

Квалификатор разрешает запись в регистр, но делает чтение нарушением ограничений типа Регистры с `volatile` предполагаются доступными лишь для записи, если не указан `atomic` Каждое чтение может наблюдать новое аппаратное состояние или само изменять регистр, например сбрасывать флаг Повторные чтения обязаны возвращать одно значение, пока программа сама не выполнила запись После первого чтения компилятор вправе заменить остальные обращения сохранённым значением

Вопрос 9 из 25

Что означает `volatile const uint32_t *reg`?

volatile const uint32_t *reg;

Значение читается один раз и затем кэшируется Сам указатель нельзя переназначить после инициализации Через указатель можно только писать, но нельзя читать Объект автоматически становится атомарным для нескольких потоков Через указатель можно выполнять наблюдаемые чтения, но нельзя записывать значение

Вопрос 10 из 25

Может ли компилятор держать volatile-значение только в регистре между двумя выражениями, полностью убрав второе чтение?

unsigned a=*reg;
unsigned b=*reg;

Ограничение действует лишь внутри функции `main` Нет: требуемые `volatile`-чтения нельзя слить в одно вопреки наблюдаемому поведению Квалификатор `volatile` учитывается только препроцессором Да: компилятор всегда может держать значение в регистре до конца функции Можно удалить второе чтение, если первое вернуло ноль

Вопрос 11 из 25

Какой тип указателя разрешён для просмотра байтового представления любого объекта?

struct packet obj = read_packet();
/* Требуется изучить объектное представление obj по отдельным байтам. */

FILE* double* int** unsigned char* struct any*

Вопрос 12 из 25

Почему чтение int через float* после каста опасно?

int x=0x3f800000;
float f=*(float*)&x;

Приведение не создаёт `float`; возможны неверное выравнивание и недопустимый тип доступа Чтение опасно только потому, что `float` всегда меньше `int` Явное приведение такого указателя является синтаксической ошибкой Единственная проблема — возможный другой порядок байтов Объект типа `int` после приведения автоматически становится неизменяемым

Вопрос 13 из 25

Как переносимо скопировать биты uint32_t в float того же размера?

float f;
uint32_t u = bits;
_Static_assert(sizeof f == sizeof u, "size");
/* перенесите объектное представление без нарушения правил доступа */

Сложить числовые значения `uint32_t` и `float` Сравнить адреса объектов и выбрать значение с меньшим адресом Разыменовать указатель `float *`, полученный приведением от `uint32_t *` Скопировать байты через `memcpy` в `float`, предварительно проверив равенство размеров Преобразовать исходное число в строку и измерить её через `strlen`

Вопрос 14 из 25

Что такое алиасинг?

Ошибка линковки из-за двух внешних символов с одним именем Несколько указателей обозначают перекрывающуюся память Любой указатель со значением NULL считается алиасом Различие порядка байтов у двух объектов одинакового типа Копирование одного файла поверх другого в файловой системе

Вопрос 15 из 25

Почему функция с двумя `int *` должна учитывать p==q?

void update(int *p,int *q){ *p+=1; *q*=2; }

Равные указатели всегда означают неопределённое поведение ещё до доступа Если пересечение не запрещено контрактом, оба указателя могут обозначать один объект Указатели на один тип нельзя сравнивать на равенство Совпадение адресов влияет только на форматный вывод `printf` Компилятор создаёт отдельные копии объекта для каждого параметра

Вопрос 16 из 25

Что обещает restrict в параметре `int *restrict dst`?

void add(size_t n,int *restrict dst,const int *restrict src);

Квалификатор гарантирует ненулевой адрес `dst` и освобождает вызывающий код от проверки `NULL` Все обращения через `dst` автоматически приобретают атомарность и межпоточную синхронизацию Изменяемые обращения к объекту в течение выполнения функции должны строиться через цепочку, основанную на `dst` `restrict` запрещает оптимизации вокруг указателя и заставляет компилятор перечитывать память Объект по адресу `dst` становится доступным только для чтения, как при `const`

Вопрос 17 из 25

Можно ли передать одной restrict-функции перекрывающиеся dst и src?

Любое перекрытие становится корректным в сборке `-O0` `restrict` проверит пересечение во время выполнения и вернёт ошибку Перекрытие допустимо, если число элементов равно ста Только если фактические обращения не нарушают правила; для обычного копирования перекрытие запрещено Да: `restrict` разрешает любые перекрытия и сам выбирает порядок копирования

Вопрос 18 из 25

Исправляет ли добавление `volatile` гонки данных и нарушения порядка доступа к аппаратной памяти?

Да для одиночных чтений и записей машинного слова: более частые обращения к памяти создают межпоточную синхронизацию Запрещает компилятору оптимизировать всю функцию, поэтому порядок всех обычных обращений становится аппаратно наблюдаемым Только на ARM, где `volatile` одновременно задаёт барьер памяти и атомарность Нет: `volatile` не исправляет гонки, нарушения псевдонимов и порядок аппаратной памяти Для циклов ожидания исправляет гонку данных, но в обычных функциях влияет лишь на оптимизацию

Вопрос 19 из 25

Почему restrict может ускорить векторизацию?

for(size_t i=0;i<n;i++) dst[i]+=src[i];

Квалификатор запускает встроенный профилировщик цикла `restrict` сам выделяет векторные регистры до запуска функции Указатель с `restrict` занимает меньше памяти Квалификатор преобразует все элементы в `float` для SIMD Компилятор может считать, что запись через `dst` не меняет данные, читаемые через `src`

Вопрос 20 из 25

Что важнее перед добавлением restrict ради скорости?

Добавить volatile Красивое имя Отключить тесты Привести указатели к void* Доказать непересечение и измерить выигрыш

Вопрос 21 из 25

Какой флаг GCC/Clang помогает предупреждать о снятии const кастом?

void update(const int *src) {
    int *p = (int *)src; /* нужно включить предупреждение о снятии квалификатора */
    *p = 1;
}

`-Wconversion`, который в основном сообщает о потенциальной потере числового диапазона `-Wwrite-strings`, изменяющий тип строковых литералов в некоторых режимах `-Wstrict-aliasing`, проверяющий часть нарушений правил доступа через несовместимые типы `-Wcast-align`, ориентированный на усиление требований выравнивания `-Wcast-qual`, предупреждающий об удалении квалификаторов при приведении

Вопрос 22 из 25

Почему проверки только со сборкой `-O0` недостаточно для поиска дефекта, связанного с псевдонимами указателей?

Сборка `-O0` гарантирует один и тот же порядок загрузок и записей на всех архитектурах Санитайзеры анализируют обращения через несовместимые типы только при уровне `-O3` При `-O0` компилятор обязан доказать и отклонить любое нарушение правил эффективного типа до запуска Неоптимизированная сборка официально отменяет правила псевдонимов для исходной программы UB из-за несовместимых псевдонимов может проявиться лишь после оптимизации, использующей гарантии языка

Вопрос 23 из 25

Что полезно сравнить при подозрении на volatile/MMIO ошибку?

cc -O2 -S driver.c -o driver.s

Посчитать обращения к имени регистра в исходнике: каждое упоминание обязано стать одной инструкцией шины Сопоставить дизассемблирование с документацией устройства и барьеров на разных оптимизациях Запустить анализ памяти Valgrind и считать отсутствие ошибок подтверждением аппаратного порядка Сопоставить только размеры объектных файлов при `-O0` и `-O2`: число обращений к регистрам следует из размера Сравнить значения регистра в отладчике без проверки, не меняет ли остановка поведение устройства

Вопрос 24 из 25

Обнаружит ли UBSan все нарушения правила строгого алиасинга?

Полное покрытие появилось в режиме C23 Нет: санитайзеры не покрывают все нарушения псевдонимов, нужна ревизия модели доступа Да, если перед каждым доступом добавить `printf` Нет, потому что нарушения псевдонимов всегда безопасны Да: UBSan гарантированно обнаруживает любой недопустимый тип доступа

Вопрос 25 из 25

Какой минимальный эксперимент убедительнее?

for cc in gcc clang; do
  $cc -O0 case.c -o a0 && ./a0
  $cc -O2 case.c -o a2 && ./a2
done

Сравнить только два снимка состояния в отладчике при одном и том же уровне оптимизации Ограничиться препроцессированным текстом, не проверяя, как его компилируют и выполняют разные реализации Оставить дефект в полном приложении и менять по одному модулю, не выделяя минимальный воспроизводимый пример Минимальный пример, два компилятора, `-O0`/`-O2` и контракт Для каждого запуска менять вход и не сохранять значение, при котором проявилось различие

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

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

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

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