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

Целочисленные переполнения и преобразования

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

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

⏱ --:--

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

Вопрос 1 из 25

Что происходит при вычислении `INT_MAX + 1` в типе `int`?

int x=INT_MAX; int y=x+1;

Результат насыщается значением `INT_MAX` Результат гарантированно становится `INT_MIN` Возникает неопределённое поведение Результат зависит от реализации, но всегда остаётся корректным Выражение автоматически вычисляется как `unsigned int`

Вопрос 2 из 25

Как безопасно проверить сложение `a + b`, если известно, что `b > 0`?

int add_checked(int a, int b, int *out) {
    /* известно, что b > 0; выбрать проверку до вычисления a + b */
}

Вычислить сумму в `long`, не проверяя ширину этого типа Преобразовать оба операнда к `unsigned int`, затем вернуть результат как `int` Сначала проверить `a > INT_MAX - b`, а сумму вычислять только после успешной проверки Вычислить сумму и проверить, стала ли она меньше `a` Обнулить `errno`, выполнить сложение и проверить `errno`

Вопрос 3 из 25

Почему вызов `abs(INT_MIN)` нельзя считать безопасным?

int m=abs(INT_MIN);

Положительный модуль `INT_MIN` не представим типом `int`, и вызов имеет неопределённое поведение `abs` возвращает `unsigned int`, поэтому значение помещается за счёт беззнакового диапазона На любой реализации `INT_MIN` равен нулю, поэтому модуль не меняет значение Функция `abs` определена только для `double`; для целых нужно использовать `fabs` Функция изменяет аргумент через скрытый указатель и поэтому требует изменяемую переменную

Вопрос 4 из 25

Как проверить произведение двух неотрицательных размеров `a * b` до вычисления?

if(b && a>SIZE_MAX/b) fail();

Преобразовать размеры к `int` и сравнить произведение с `SIZE_MAX` Сначала умножить, затем проверить, совпадает ли `(a * b) / b` с `a` Проверять переполнение не нужно: `size_t` всегда достаточно велик для выделения памяти Выполнить умножение через `double`, затем отбросить дробную часть Если `b != 0`, проверить `a > SIZE_MAX / b`; умножать только после этого

Вопрос 5 из 25

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

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

Вопрос 6 из 25

Каков результат `UINT_MAX + 1u`?

unsigned x=UINT_MAX; printf("%u\n",x+1u);

Ноль по модулю `UINT_MAX + 1` Неопределённое поведение Обязательная ошибка компиляции Значение `INT_MIN` Значение `UINT_MAX`

Вопрос 7 из 25

Почему выражение `size_t remain = capacity - used;` опасно без предварительной проверки?

size_t remain = capacity - used;
/* Оба значения получены извне, отношение между ними ещё не проверено. */

Переменная `remain` неявно становится знаковой Если `used > capacity`, беззнаковое вычитание даст очень большое значение Вычитание двух значений `size_t` запрещено стандартом Ошибка возникает только на 32-битных системах `size_t` является вещественным типом и теряет точность

Вопрос 8 из 25

Как корректно обойти массив в обратном порядке, если индекс имеет тип `size_t`?

for(size_t i=n;i-- > 0;) use(a[i]);

`for (i = n + 1; i; ++i)` `while (i <= 0) --i;` `for (i = 0; i < n; --i)` `for (i = n; i-- > 0; )` `for (i = n - 1; i >= 0; --i)`

Вопрос 9 из 25

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

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

Вопрос 10 из 25

Почему условие `n - 1 < n` ложно при `size_t n = 0`?

size_t n=0; printf("%d\n",n-1<n);

`n` неявно становится знаковым Само вычитание имеет неопределённое поведение Компилятор удаляет переменную `n` как константу `n - 1` переходит к `SIZE_MAX`, поэтому оказывается больше `n` Оператор сравнения не работает с `size_t`

Вопрос 11 из 25

Как вычисляется выражение `a + b`, если `a` и `b` имеют тип `unsigned char`, а диапазона `int` достаточно?

unsigned char c=a+b;

Операнды преобразуются к `float` Операнды автоматически преобразуются к `size_t` Операнды становятся `int`; сужение идёт лишь при присваивании Сложение всегда имеет неопределённое поведение Операнды складываются как `unsigned char` и переходят по модулю до вычисления выражения

Вопрос 12 из 25

Почему приведение результата `(uint32_t)(x << 24)` может быть запоздалым, если `x` имеет тип `signed char`?

uint32_t v=(uint32_t)(x<<24);

Компилятор всегда игнорирует приведение после сдвига Проблема возникает только из-за порядка байтов процессора Тип `uint32_t` недостаточно широк для 24-битного сдвига Оператор сдвига возвращает указатель, который нельзя привести к целому `x` сначала становится `int`; приводить нужно до сдвига

Вопрос 13 из 25

Какой тип имеет результат выражения `sizeof(char) + 1`?

#define EXPR (sizeof(char) + 1)
/* определите тип выражения EXPR */

`ptrdiff_t`, так как выражение связано с размерами объектов `char`, поскольку `sizeof(char)` всегда равен единице `size_t` после обычных арифметических преобразований `int`, потому что литерал 1 преобразует весь результат `double`, поскольку арифметика размеров выполняется с запасом

Вопрос 14 из 25

Почему самостоятельное выражение `~(uint8_t)0` на типичной реализации с 32-битным `int` не имеет значения `0xFF`?

unsigned x=~(uint8_t)0;

Инверсия выполняется после сохранения в `x`, и результат определяется порядком байтов целевой системы При продвижении `uint8_t` сохраняет ширину восемь бит, но меняет знаковость на `signed char` Явное приведение к `uint8_t` отменяется обычными арифметическими преобразованиями только при присваивании Перед инверсией значение продвигается до `int`, поэтому единицами становятся и старшие биты результата Оператор `~` применим только к `unsigned int`, поэтому выражение должно быть отклонено компилятором

Вопрос 15 из 25

Как избежать неожиданного продвижения типов при упаковке байтов в `uint32_t`?

uint8_t b0, b1, b2, b3;
uint32_t v = /* безопасно упаковать четыре байта */;

Полагаться на знаковость обычного `char` Скопировать адрес байта в указатель `uint32_t *` Привести к `uint32_t` только итог всего выражения Использовать исключительно литералы типа `int` Преобразовать каждый байт к `uint32_t` до сдвига и объединения

Вопрос 16 из 25

Какое значение печатает выражение `-1 < 1u` по правилам языка?

printf("%d\n",-1<1u);

Компилятор обязан отклонить выражение 1 Результат зависит от порядка байтов Поведение не определено 0

Вопрос 17 из 25

Как безопасно сравнить знаковый индекс `int index` с размером `size_t n`?

if(index>=0 && (size_t)index<n) use(a[index]);

Сравнивать адреса элементов вместо индекса Сначала проверить `index >= 0`, затем сравнить `(size_t)index < n` Сравнить `abs(index)` с `n` Сначала привести `n` к `int`, не проверяя диапазон Сразу проверить `index < n`

Вопрос 18 из 25

Почему такой код опасен, если `read()` вернёт ошибку?

size_t n = (size_t)read(fd, buf, cap);
process_bytes(buf, n);

`-1` из `ssize_t` станет огромным значением `size_t` Проблема существует только для сетевых сокетов `read` возвращает указатель на буфер `size_t` слишком мал для количества прочитанных байтов `read` возвращает вещественное число

Вопрос 19 из 25

Можно ли привести `size_t` к `int` только ради удаления предупреждения компилятора?

Да, достаточно проверить, что значение положительно Нет, преобразование `size_t` к `int` запрещено при любых значениях Да, любое явное приведение гарантирует сохранение значения Только после явной проверки `n <= INT_MAX` или при доказанном контрактом диапазоне Да, если программа собрана для 64-битной системы

Вопрос 20 из 25

Как безопасно сравнить `ptrdiff_t d` с ограничением `size_t limit`?

if(d>=0 && (size_t)d<limit) ...

Сразу вычислить `d < limit` Сначала проверить `d >= 0`, затем сравнить `(size_t)d < limit` Выполнить беззнаковое вычитание `limit - d` Всегда привести `limit` к `ptrdiff_t` Сравнить адреса через формат `%p`

Вопрос 21 из 25

Где стандартно определены границы типа `int`?

void print_int_range(void) {
    printf("%d %d\n", /* нижняя граница */, /* верхняя граница */);
}

В переменной `errno`, которую реализация заполняет нижней и верхней границей при запуске В десятичных литералах `-2147483648` и `2147483647`, одинаковых для всех допустимых реализаций В макросах `INT_MIN` и `INT_MAX` заголовка `<limits.h>` В `<stdio.h>`, поскольку спецификатор `%d` определяет диапазон печатаемого значения Только через `sizeof(int)`: число байтов однозначно задаёт диапазон независимо от `CHAR_BIT` и представления

Вопрос 22 из 25

Как в GCC или Clang проверить знаковое сложение на переполнение, не выполняя опасную операцию?

int out;
/* выбрать средство GCC или Clang, которое проверяет a + b
   без предварительного выполнения опасного знакового сложения */

Вычислить сумму в исходном типе и только после этого привести результат к более широкому типу Сначала выполнить `a + b`, а затем по знакам операндов проверить, изменился ли знак результата Собрать с `-O0`: без оптимизации знаковое переполнение получает определённое поведение Использовать `__builtin_add_overflow(a, b, &out)` Объявить операнды `volatile`: тогда компилятор обязан выполнить сложение без переполнения

Вопрос 23 из 25

Какие ошибки при выполнении программы обнаруживает обычная конфигурация UBSan со включённой проверкой знакового переполнения?

Все переходы беззнаковых значений по модулю Выполненные пути со знаковым переполнением и иным UB Только синтаксические ошибки времени компиляции Сетевые тайм-ауты и ошибки протокола Любую ошибку диапазона даже в невыполненной ветви

Вопрос 24 из 25

Какие тесты лучше всего проверяют функцию безопасного сложения?

Только проверка `sizeof` типов без вычисления результатов сложения Только положительные операнды, потому что переполнение возникает лишь выше нуля Несколько случайных положительных пар без обязательных предельных значений Пары около минимума и максимума, `-1`, `0`, `1` и сравнение с более широкой эталонной арифметикой Один обычный случай `1 + 1`, подтверждающий работу основной ветви

Вопрос 25 из 25

Что сообщает предупреждение `-Wsign-conversion`?

cc -Wall -Wextra -Wconversion -Wsign-conversion file.c

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

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

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

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

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