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

Представление данных в памяти

Тест проверяет, как логическое значение становится байтами: порядок байтов, выравнивание, байты заполнения и объектное представление. Главная ловушка — принять наблюдение на одной платформе за контракт языка или сетевого формата.

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

⏱ --:--

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

Вопрос 1 из 25

Что показывает порядок байтов?

Знак числа Размер указателя Порядок байтов многобайтового значения Порядок битов в исходнике Выравнивание

Вопрос 2 из 25

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

const unsigned char p[4] = { 0x78, 0x56, 0x34, 0x12 };
/* прочитать little-endian uint32_t */

`uint32_t x; memcpy(&x,p,4);` — результат всегда little-endian независимо от хостаreturn memcpy(&x,p,4),x; `uint32_t x = ntohl(*(const uint32_t *)p);`return (uint32_t)p; `uint32_t x = *(const uint32_t *)p;`return *(const uint32_t*)p; `uint32_t x=(uint32_t)p[0]<<24|(uint32_t)p[1]<<16|(uint32_t)p[2]<<8|p[3];`return p[0]+p[1]+p[2]+p[3]; `uint32_t x=(uint32_t)p[0]|(uint32_t)p[1]<<8|(uint32_t)p[2]<<16|(uint32_t)p[3]<<24;`return ((uint32_t)p[0]<<24)|((uint32_t)p[1]<<16)|((uint32_t)p[2]<<8)|p[3];

Вопрос 3 из 25

Почему копирования четырёх сетевых байтов прямо в `uint32_t` недостаточно?

uint32_t x; memcpy(&x,buf,4);

Достаточно выровнять `buf`; порядок байтов после этого совпадёт автоматически Байты окажутся в порядке хоста; для сетевого числа нужно отдельное преобразование Нужно заменить `memcpy` на `strncpy`, потому что источник — массив байтов `memcpy` сам преобразует сетевой порядок в порядок хоста Копирование допустимо только в знаковый `int32_t`

Вопрос 4 из 25

Что делает `ntohl(net)` с 32-битным значением сетевого протокола?

uint32_t host=ntohl(net);

Выделяет новый буфер и копирует в него число в текстовом виде Преобразует адрес сетевого буфера в указатель, пригодный для чтения Преобразует 32-битное число из сетевого порядка байтов в порядок хоста Проверяет, помещается ли значение в тип `long` текущей платформы Меняет порядок байтов только у 16-битных чисел

Вопрос 5 из 25

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

uint16_t x = 1;
/* определите порядок байтов, не обращаясь через несовместимый тип */

Передать адрес объекта в `strlen` и проверить длину Сравнить `sizeof(uint16_t)` и `sizeof(unsigned char)` Прочитать объект через `float *` и проверить младший разряд Прочитать первый `unsigned char` у `uint16_t` со значением 1 Сравнить числовой адрес объекта с нулевым указателем

Вопрос 6 из 25

Что возвращает `_Alignof(double)`?

size_t a=_Alignof(double);

Размер объекта `double`, то есть значение, полностью эквивалентное `sizeof(double)` Требование выравнивания объектов `double`, выраженное в байтах Число байтов заполнения, которое обязательно следует за каждым `double` в структуре Наименьший фактический адрес любого объекта `double` в текущем процессе Максимальное выравнивание, поддерживаемое реализацией для всех скалярных типов

Вопрос 7 из 25

Гарантирует ли `malloc` подходящее выравнивание для обычных объектных типов?

Да для любого повышенного выравнивания, включая требования расширений процессора Только для целых типов; структуры и вещественные требуют `aligned_alloc` Только если размер блока кратен `sizeof(max_align_t)` Нет, `malloc` гарантирует лишь выравнивание для `char` Да, для обычных объектных типов, если запрошенного блока достаточно

Вопрос 8 из 25

Почему `uint32_t *p=(uint32_t*)(buf+1); *p` опасно?

unsigned char buf[8];
uint32_t x=*(uint32_t*)(buf+1);

Возможны неверное выравнивание и нарушение effective type Локальный массив `buf` всегда преобразуется в NULL Арифметика `buf + 1` запрещена для массива unsigned char Единственная проблема — различный порядок байтов платформы `uint32_t` является знаковым типом и меняет старший бит

Вопрос 9 из 25

Как безопасно загрузить невыровненное 32-битное значение в представлении хоста?

const unsigned char *p = packet + 1; /* адрес может быть невыровнен */
uint32_t x;
/* Нужно перенести sizeof x байтов в правильно выровненный объект x. */

Использовать strlen Разыменовать результат приведения типа memcpy(&x,p,sizeof x) Привести указатель к `volatile`-типу Сдвинуть p назад без проверки

Вопрос 10 из 25

Какое ограничение установлено для `aligned_alloc` в C11?

Функция возвращает автоматический объект, который нельзя освобождать Размер должен быть кратен выравниванию, а само выравнивание — допустимым Выравнивание задаётся в битах, а не в байтах Допустимо только выравнивание, равное `sizeof(void *)` Размер может быть любым, если указатель затем освобождается через `free`

Вопрос 11 из 25

Зачем структуре может понадобиться заполнение после последнего поля?

Чтобы строковые поля структуры всегда завершались нулевым байтом Чтобы скрыть закрытые поля от кода другой единицы трансляции Чтобы запретить копирование структуры обычным присваиванием Чтобы привести порядок байтов всех полей к сетевому Чтобы соседние элементы массива структур сохраняли требуемое выравнивание

Вопрос 12 из 25

Что может изменить перестановка полей?

struct A{ char c; double d; int i; };
struct B{ double d; int i; char c; };

Число байтов заполнения и общий `sizeof` структуры Порядок байтов процессора для каждого целого поля Правила выделения структуры функциями `malloc` и `free` Размеры самих типов `char`, `int` и `double` Только имена полей в отладочной информации, но не раскладку

Вопрос 13 из 25

Почему `memcmp(&a,&b,sizeof a)` может сказать “не равны” при равных полях?

return memcmp(&a,&b,sizeof a)==0;

Стандарт запрещает сравнивать структуры с полями float Байты заполнения могут различаться и не входят в значения полей Такое сравнение ошибочно только для нулевых указателей `memcmp` нельзя применять ни к каким объектам структурного типа Два объекта одной структуры всегда получают разные типы

Вопрос 14 из 25

Можно ли включать байты заполнения структуры в стабильный файловый формат?

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

Вопрос 15 из 25

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

struct record {
    char tag;
    double value;
    unsigned flags;
};
/* Требуется получить смещение поля value в этой реализации. */

Сложить sizeof предыдущих С помощью strlen Вычесть строковые адреса Всегда 0 offsetof(struct T,field)

Вопрос 16 из 25

Что в стандарте C называют объектным представлением значения?

Адрес первого байта объекта, представленный целым типом `uintptr_t` Число значащих байтов без учёта заполнения и альтернативных представлений Набор байтов `unsigned char`, составляющих объект Последовательность символов, которой `printf` отображает значение объекта Совокупность имён полей и типов, доступная компилятору во время трансляции

Вопрос 17 из 25

Гарантирует ли одно значение `float` одинаковое представление байтами на всех платформах?

Нет: формат, порядок байтов и представления NaN могут различаться Да после приведения значения к `unsigned char *` перед передачей Да, стандарт C требует от `float` двоичный формат IEEE 754 на всех платформах Да для конечных чисел; различия разрешены только для бесконечностей Нет только на системах с 16-битным `int`; ширина целых определяет формат `float`

Вопрос 18 из 25

Когда корректно копировать структуру в другой объект через `memcpy`?

struct S dst,src; memcpy(&dst,&src,sizeof dst);

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

Вопрос 19 из 25

Почему чтение неинициализированного автоматического int опасно?

int x; printf("%d\n",x);

Проблема ограничивается предупреждением о стиле и не влияет на поведение программы Значение не определено; чтение неопределённого представления может иметь неопределённое поведение Автоматический `int` без инициализатора всегда получает ноль перед первым чтением Неинициализированная переменная содержит собственный адрес, приведённый к `int` Компилятор неявно вызывает `malloc` и оставляет в переменной адрес выделенного блока

Вопрос 20 из 25

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

Можно для некриптографических задач, если структура достаточно велика Да, но только после чтения каждого байта через `unsigned char` Да, если структура выделена через `calloc`, а не находится в стеке Нет: байты заполнения не являются источником случайности и могут раскрыть данные Можно, если поле структуры объявлено `volatile` и читается несколько раз

Вопрос 21 из 25

Как быстро посмотреть байты файла со смещениями и печатным представлением?

$ ls -l packet.bin
-rw-r--r-- 1 user user 64 packet.bin
$ /* выберите команду для просмотра смещений и байтов файла */

`od -c file`, показывающая символы, но не требуемый канонический шестнадцатеричный вид `readelf -h file`, выводящая заголовок ELF, а не все байты `nm file`, показывающая таблицу символов объектного файла `strings file`, извлекающая лишь печатные фрагменты `hexdump -C file`, выводящая смещения, шестнадцатеричные байты и ASCII

Вопрос 22 из 25

Какой флаг Clang/GCC включает набор проверок UBSan, в том числе диагностику некоторых неверно выровненных доступов?

unsigned char raw[sizeof(uint32_t) + 1];
uint32_t value = *(uint32_t *)(raw + 1); /* возможное нарушение выравнивания */
/* Выберите флаг диагностической сборки. */

`-Wcast-align`, выдающий статическое предупреждение без проверки выполненного доступа `-fsanitize=address`, ориентированный прежде всего на границы и время жизни памяти `-fsanitize=thread`, предназначенный для гонок данных `-fno-strict-aliasing`, меняющий оптимизационные предположения, но не добавляющий диагностику `-fsanitize=undefined`, включающий группу проверок неопределённого поведения

Вопрос 23 из 25

Что полезно вывести для ABI-диагностики структуры?

struct T {
    char tag;
    int x;
    double value;
};
/* сравниваются две сборки с разным ABI */

Длину машинного кода функции, которая принимает структуру по значению `sizeof`, `_Alignof` и `offsetof` для каждого значимого поля Сумму `sizeof` всех объявленных полей без учёта промежутков Адрес первого экземпляра структуры в одном запуске программы Только `sizeof(struct T)`, не показывая требования выравнивания и смещения полей

Вопрос 24 из 25

Зачем `_Static_assert(sizeof(uint32_t)==4,...)`?

Выполнить проверку размера во время запуска программы Установить требуемый порядок байтов для всех объектов Выделить четыре байта памяти для каждого `uint32_t` Остановить сборку при неверном предположении о формате Скрыть предупреждение компилятора о преобразовании типа

Вопрос 25 из 25

Почему один шестнадцатеричный снимок памяти на x86 не доказывает переносимость?

Потому что шестнадцатеричный вывод всегда переставляет байты относительно памяти Потому что переносимость можно доказать только сборкой без оптимизации Потому что содержимое файла неизбежно меняется после каждого просмотра Потому что x86 не поддерживает объектное представление типов языка C Он показывает лишь одну реализацию, ABI и порядок байтов на одном запуске

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

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

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

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