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

Типы, переменные и операторы C

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

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

⏱ --:--

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

Вопрос 1 из 20

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

size_t uint32_t ptrdiff_t unsigned long unsigned int

Вопрос 2 из 20

Что напечатает программа на любой реализации C17, где CHAR_BIT не меньше 8?

#include <limits.h>
#include <stdio.h>

int main(void) {
    unsigned char x = 0;
    x = x - 1;
    printf("%d\n", x == UCHAR_MAX);
}

255 1 Зависит от знаковости char Поведение не определено 0

Вопрос 3 из 20

В коде счётчик может принимать значения от 0 до 70 000. Какое объявление гарантирует достаточный диапазон по стандарту C17?

#include <limits.h>

/* count должен представлять каждое значение от 0 до 70000 на любой реализации C17. */
count = 70000;

unsigned long count; short count; uint16_t count; unsigned short count; unsigned int count;

Вопрос 4 из 20

Какой вывод гарантирован стандартом?

#include <stdio.h>

int main(void) {
    printf("%zu %zu\n", sizeof(char), sizeof(short));
}

Стандарт разрешает `short` занимать меньше единиц `sizeof`, чем `char` Размеры `char` и `short` обязаны совпадать, поскольку оба подвергаются целочисленным продвижениям Конкретные числа зависят от реализации, но `sizeof(char) == 1` и `sizeof(short) >= sizeof(char)` `sizeof(char)` равен 1, а `sizeof(short)` обязан быть ровно 2 на любой реализации `sizeof(char)` равен 1, а `sizeof(short)` не меньше 2 единиц `sizeof(char)`

Вопрос 5 из 20

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

/* Какой тип результата выбрать? */
result = end - begin;

unsigned long intmax_t size_t ptrdiff_t uintptr_t

Вопрос 6 из 20

Почему условие может оказаться ложным, хотя математически сумма равна 0.3?

#include <stdio.h>

int main(void) {
    double x = 0.1 + 0.2;
    printf("%d\n", x == 0.3);
}

Литерал 0.1 имеет тип float и переполняется Оператор == запрещён для double Операция + для double выполняется как целочисленная Десятичные дроби 0.1 и 0.2 обычно не представимы точно в двоичном формате Компилятор обязан округлить сумму вверх

Вопрос 7 из 20

Какое изменение лучше всего сохраняет точность при суммировании миллиона небольших значений, если интерфейс сейчас использует float?

Приводить каждый элемент к int перед сложением Заменить цикл рекурсией После каждого сложения округлять до двух знаков Сравнивать результат с нулём через == Суммировать в double, даже если входные элементы float

Вопрос 8 из 20

Что напечатает программа при обычной реализации IEEE 754 с точным представлением всех целых до 2^53, если double имеет 53 бита точности?

#include <stdio.h>

int main(void) {
    double x = 9007199254740992.0;
    printf("%d\n", x + 1.0 > x);
}

Будет напечатано `0`: при указанной точности `x + 1.0` округляется обратно к `x` Будет напечатано `2`, поскольку результат сравнения хранит разность показателей степени Поведение неопределено, потому что литерал `9007199254740992.0` превышает диапазон точных целых типа `int` Будет напечатано `1`, потому что прибавление единицы к конечному `double` всегда меняет значение Результат зависит от режима округления и точности `double`, даже при явно заданных в условии предпосылках

Вопрос 9 из 20

Какой спецификатор printf корректен для переменной типа double?

double temperature = 21.75;
printf("...\n", temperature);

%zu %d %Lf %lld %f

Вопрос 10 из 20

Функция проверяет, близки ли два результата измерения порядка 10^9 и 10^-9. Какой подход наиболее надёжен?

int nearly_equal(double a, double b) {
    /* Какой принцип проверки выбрать? */
}

Сравнение строк, полученных через printf Один фиксированный абсолютный допуск 1e-6 для всех значений Только точное сравнение через == Приведение обоих значений к long Сочетание абсолютного и относительного допуска по требованиям

Вопрос 11 из 20

Какой вывод гарантирован?

#include <stdio.h>

static int bump(int *p) { ++*p; return 1; }

int main(void) {
    int x = 0;
    int r = x && bump(&x);
    printf("%d %d\n", r, x);
}

1 0 0 1 0 0 1 1 Поведение не определено

Вопрос 12 из 20

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

#include <stdio.h>

int main(void) {
    int x = 1 + 3 * 2 + 2;
    printf("%d\n", x);
}

12 8 7 9 Поведение не определено

Вопрос 13 из 20

Почему выражение нельзя использовать для надёжного вычисления результата?

#include <stdio.h>

int main(void) {
    int i = 1;
    printf("%d\n", i++ + ++i);
}

Оператор + всегда вычисляет правый операнд первым Между двумя изменениями i нет требуемого упорядочивания printf принимает только одно выражение Постфиксный ++ не разрешён для int Значение i станет отрицательным

Вопрос 14 из 20

Как переписать условие, чтобы намерение было ясным и значение x увеличивалось только при готовом объекте?

struct item *item = get_item();
size_t x = current;

if (item != NULL && item->ready && x++ < limit) {
    handle(item, x);
}

`if (item && (item->ready || x++ < limit)) handle(item, x);`if (ready ? x++ : limit) use(x); `if (item && item->ready) { if (x < limit) { ++x; handle(item, x); } }`if (ready && x < limit) { ++x; use(x); } `if (item && item->ready && ++x <= limit) handle(item, x);`if (ready && x++ < limit) use(x); `if (item->ready && x < limit) { ++x; handle(item, x); }`if (++x < limit || ready) use(x); `if (x < limit) { ++x; if (item && item->ready) handle(item, x); }`if (x++ < limit & ready) use(x);

Вопрос 15 из 20

В проверке флага написано `if (flags & READY == READY)`. Как компилятор расставляет скобки?

Выражение синтаксически недопустимо flags & READY, затем результат сравнивается с READY (flags & READY ==) READY flags & (READY == READY) (flags & READY) == READY

Вопрос 16 из 20

Что напечатает программа на реализации, где int может представить все значения unsigned char?

#include <stdio.h>

int main(void) {
    unsigned char a = 250, b = 10;
    unsigned char c = a + b;
    printf("%d\n", c == 4);
}

0 1 -1 255 Поведение не определено

Вопрос 17 из 20

Почему сравнение `s < u` печатает 0, хотя `s` содержит отрицательное значение?

#include <stdio.h>

int main(void) {
    unsigned int u = 1;
    int s = -1;
    printf("%d\n", s < u);
}

-1 преобразуется к unsigned int и становится UINT_MAX Смешанное сравнение знакового и беззнакового целого само по себе имеет неопределённое поведение Литерал `1` получает тип `_Bool`, и сравнение выполняется только по истинности `u` преобразуется к `signed char`, поэтому единица становится отрицательной Оператор `<` сравнивает адреса временных объектов, созданных для обоих операндов

Вопрос 18 из 20

Как безопасно преобразовать size_t n в int перед передачей старому API?

int legacy_set_count(int count);

int send_count(size_t n) {
    /* выбрать безопасное преобразование */
}

`int v=(int)n; if(v<0) return -1; return legacy_set_count(v);` — отрицательность обнаруживает любое сужениеint x = n > INT_MAX ? INT_MAX : (int)n; `return legacy_set_count(n>INT_MAX ? INT_MAX : (int)n);` — насыщение сохраняет контракт старого APIint x = (short)n; `if(sizeof n>sizeof(int)) return -1; return legacy_set_count((int)n);` — ширина типа важнее значенияint x = (unsigned int)n; `if (n>INT_MAX) return -1; return legacy_set_count((int)n);`

if (n > (size_t)INT_MAX) return RANGE_ERROR;
int x = (int)n;

`return legacy_set_count((int)n);` — явное приведение фиксирует переносимое насыщение значенияint x = (int)n;

Вопрос 19 из 20

Что гарантированно происходит при преобразовании положительного double 3.9 к int?

#include <stdio.h>

int main(void) {
    printf("%d\n", (int)3.9);
}

Всегда возникает исключение Результат зависит от режима округления Получается 3 Поведение не определено Получается 4

Вопрос 20 из 20

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

Преобразование enum к int для журналирования Приведение отрицательного int к unsigned для сериализации без описанного формата Преобразование int к double перед делением Проверенное преобразование size_t к int после сравнения с INT_MAX Приведение указателя на выделенный блок void* к указателю на нужный объект в C

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

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

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

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