Раздел 4 — Выражения, ввод и вывод

Программа раздела — линейная: инструкции выполняются по одной сверху вниз, каждая ровно один раз. Это базовая структура «следование» из раздела 2. Пример — алгоритм «сколько автобусов» из раздела 2:

/* Сколько автобусов заказать: N учеников, c мест в автобусе */
#include <stdio.h>                         /* 1. подключение библиотек */

int main(void)                             /* 2. главная функция */
{
    int students = 0, seats = 0;             /* 3. объявления */
    printf("Students and seats: ");         /* 4. ввод */
    scanf("%d %d", &students, &seats);

    int buses = (students + seats - 1) / seats; /* 5. вычисления */
    int free_seats = buses * seats - students;

    printf("Buses: %d, free seats: %d\n", buses, free_seats);  /* 6. вывод */
    return 0;                                 /* 7. код завершения */
}

Students and seats: 50 45          Students and seats: 90 45
Buses: 2, free seats: 40           Buses: 2, free seats: 0

Почему (students + seats - 1) / seats округляет вверх. Целое деление отбрасывает остаток. Прибавка seats - 1 — на единицу меньше, чем нужно для «лишнего» автобуса: если students делится на seats нацело, прибавка не дотягивает до следующего целого (90 + 44 = 134, 134 / 45 = 2); если остаток есть хотя бы 1 — дотягивает (91 + 44 = 135, 135 / 45 = 3). Формула верна для целых положительных чисел.

Комментарии пишутся между /* и */ или от // до конца строки (с C99). Компилятор их не читает: комментарий объясняет зачем, а не пересказывает код.

x = выражение — вычислить правую часть и записать в x. В C присваивание — операция, у неё есть значение (присвоенное), поэтому a = b = 0 работает: сначала b = 0, затем a = 0.

У ++ две формы. Отдельной инструкцией они не отличаются. Внутри выражения префиксная ++i даёт новое значение, постфиксная i++ — старое:

int i = 5;
int a = ++i;     /* i = 6, a = 6 */
int b = i++;     /* b = 6, i = 7 */

Операции + - * / работают как в математике, с одним отличием: если оба операнда целые, деление целое — дробная часть отбрасывается (раздел 3, пункт 06). Операция % — остаток от деления, только для целых.

Пара / и % разбирает число на части. Секунды → часы, минуты, секунды:

/* Секунды от начала суток → часы, минуты, секунды */
#include <stdio.h>

int main(void)
{
    int total = 0;
    printf("Seconds: ");
    scanf("%d", &total);

    int hours = total / 3600;
    int minutes = total % 3600 / 60;
    int seconds = total % 60;
    printf("%02d:%02d:%02d\n", hours, minutes, seconds);
    return 0;
}

Seconds: 3725      ->  01:02:05
Seconds: 86399     ->  23:59:59
Seconds: 0         ->  00:00:00

total % 3600 / 60: % и / одного приоритета и выполняются слева направо — сначала остаток после целых часов (3725 % 3600 = 125), потом минуты в нём (125 / 60 = 2). Последняя цифра числа — n % 10, число без неё — n / 10; это понадобится для цифр числа в разделе 6.

Операции выполняются по приоритету, при равном — по ассоциативности. Таблица — для операций, которые встретятся до раздела 10; выше в таблице — раньше выполняется.

Примеры: 2 + 3 * 4 = 14; (2 + 3) * 4 = 20; 10 - 4 - 3 = 3 (слева направо: (10 - 4) - 3); -2 * 3 = −6; (double)7 / 2 = 3.5 — приведение выполняется раньше деления. Математическая формула (a + b) / (2c) в C — (a + b) / (2 * c): без скобок (a + b) / 2 * c — это (a + b) / 2 · c.

Функции из <math.h> принимают и возвращают double:

Расстояние между точками (x₁; y₁) и (x₂; y₂):

/* Расстояние между двумя точками */
#include <stdio.h>
#include <math.h>

int main(void)
{
    double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
    printf("x1 y1 x2 y2: ");
    scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);

    double dx = x2 - x1;
    double dy = y2 - y1;
    double distance = sqrt(dx * dx + dy * dy);
    printf("Distance: %.3f\n", distance);
    return 0;
}

x1 y1 x2 y2: 0 0 3 4        ->  Distance: 5.000
x1 y1 x2 y2: 0 0 1 1        ->  Distance: 1.414

Квадрат — умножением dx * dx, а не pow(dx, 2): короче и точнее. pow — для дробных и больших степеней.

printf(формат, значения…) выводит строку формата, заменяя каждую спецификацию — от % до буквы — очередным значением:

Ширина поля — число после %: значение дополняется пробелами слева до этой ширины. Минус — выравнивание влево, ноль — дополнение нулями:

printf("[%5d]\n", 42);        /* [   42] */
printf("[%-5d]\n", 42);       /* [42   ] */
printf("[%05d]\n", 42);       /* [00042] */
printf("[%8.3f]\n", 3.14159); /* [   3.142] — 8 символов всего, 3 после точки */
printf("[%-8s]|\n", "abc");   /* [abc     ]| */

Так строятся таблицы с ровными столбцами. Специальные символы в строке: \n — перевод строки, \t — табуляция, \" — кавычка, \\ — обратная косая черта.

scanf(формат, адреса…) читает из ввода значения по спецификациям и записывает их в переменные. Ему нужны не значения переменных, а их адреса — знак & перед именем (что такое адрес, подробно — раздел 10):

int n;
double price;
char grade;
scanf("%d", &n);          /* целое */
scanf("%lf", &price);     /* double — %lf, не %f */
scanf(" %c", &grade);     /* пробел перед %c пропускает пробелы и переводы строки */

%d и %lf сами пропускают пробелы, табуляции и переводы строки перед числом, поэтому числа можно вводить в одной строке через пробел или каждое на своей. %c читает любой следующий символ, в том числе перевод строки после предыдущего числа, — поэтому перед ним пробел.

scanf возвращает число успешно прочитанных значений. Если вместо числа введено abc, чтение не удастся: scanf("%d", &n) вернёт 0, а n останется без значения. Программа, которая не смотрит на результат scanf, считает дальше по мусору:

/* Что возвращает scanf */
#include <stdio.h>

int main(void)
{
    int a = 0, b = 0;
    printf("a b: ");
    int read = scanf("%d %d", &a, &b);
    printf("read %d, a = %d, b = %d\n", read, a, b);
    return 0;
}

a b: 12 34         ->  read 2, a = 12, b = 34
a b: 12 x          ->  read 1, a = 12, b = 0
a b: x 34          ->  read 0, a = 0, b = 0

Проверка результата — if (scanf(…) != 2) — делается ветвлением, оно в разделе 5. До тех пор программы курса считают, что ввод верный, а начальные значения переменных задаются, чтобы вместо мусора был хотя бы 0.

Задача: товар стоит P ₽ без НДС, куплено q штук со скидкой d %. Посчитать сумму без скидки, скидку, НДС 20 % на сумму со скидкой и итог. Все суммы — в рублях с копейками.

1. Модель. sum = P · q; discount = sum · d / 100; vat = (sum − discount) · 0,20; total = sum − discount + vat. Каждая сумма округляется до копеек: x = round(x · 100) / 100. P, d — double, q — int.
2. Тесты до программы. 1500, 3, 10 → 4500.00, 450.00, 810.00, 4860.00. 100, 1, 0 → 100.00, 0.00, 20.00, 120.00.
3. Программа:

/* Покупка: сумма, скидка, НДС, итог */
#include <stdio.h>
#include <math.h>

const double VAT_RATE = 0.20;

int main(void)
{
    double price = 0, discount_pct = 0;
    int quantity = 0;
    printf("Price, quantity, discount %%: ");
    scanf("%lf %d %lf", &price, &quantity, &discount_pct);

    double sum = round(price * quantity * 100) / 100;
    double discount = round(sum * discount_pct) / 100;   /* sum * d / 100, в копейках */
    double vat = round((sum - discount) * VAT_RATE * 100) / 100;
    double total = sum - discount + vat;

    printf("Sum:      %10.2f\n", sum);
    printf("Discount: %10.2f\n", discount);
    printf("VAT:      %10.2f\n", vat);
    printf("Total:    %10.2f\n", total);
    return 0;
}

Price, quantity, discount %: 1500 3 10      Price, quantity, discount %: 100 1 0
Sum:         4500.00                         Sum:          100.00
Discount:     450.00                         Discount:       0.00
VAT:          810.00                         VAT:           20.00
Total:       4860.00                         Total:         120.00

4. Тестирование: выводы совпали с тестами. Ещё один тест — с копейками: 99.99, 7, 5 → сумма 699.93, скидка 35.00 (34,9965 ₽ округлено), НДС 132.99, итог 797.92.

discount_pct, а не d; VAT_RATE — константа; в формате %%, потому что одиночный % начал бы спецификацию. Ширина %10.2f выравнивает суммы по правому краю — так читают денежные таблицы.