Операторы в C: арифметика, логика и приоритет

Операторы — это глаголы языка C: они берут значения и порождают новые. Их около 40, но дюжина покрывает большую часть кода, а у двух из них ловушки настолько острые, что заслуживают отдельных разделов.

Арифметические операторы

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - целочисленное деление! */
    printf("a %% b  = %d\n", a % b);  /* 2  - остаток */
    printf("-a     = %d\n", -a);      /* унарный минус */
    return 0;
}

(%% в строке формата выводит сам знак процента — одиночный % начал бы спецификатор формата.)

Пять бинарных арифметических операторов — это + - * / %, плюс унарный - для смены знака и +, который практически ничего не делает.

Ловушка целочисленного деления

a / b с двумя целыми выполняет целочисленное деление и отбрасывает остаток. Никакого округления нет — результат усекается в сторону нуля.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* деление происходит СНАЧАЛА, в целых числах */
    printf("wrong average = %f\n", wrong);   /* 3.000000 */
    return 0;
}

Последний случай — это баг, который доживает до продакшена. Присваивание в double не помогает: деление total / count уже выполнено и уже является int до того, как произойдёт присваивание. Исправление — сделать один операнд числом с плавающей точкой внутри выражения, обычно с помощью приведения типа.

Два связанных правила: деление на ноль в целых числах — неопределённое поведение, которое обычно приводит к аварийному завершению программы, а INT_MIN / -1 вызывает переполнение.

Оператор остатка

% даёт остаток и работает только с целыми числами:

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d - чётное\n", i);
        } else {
            printf("%d - нечётное\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d секунд = %dч %dм %dс\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

Проверка x % 2 == 0 на чётность и использование % n для зацикливания индекса по массиву — два повседневных применения.

С отрицательными числами % в C следует знаку делимого:

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, а не 2 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

Поэтому x % 2 == 1 — сломанная проверка на нечётность, если x может быть отрицательным: -7 % 2 равно -1. Используйте вместо неё x % 2 != 0.

Для остатка от чисел с плавающей точкой % даёт ошибку компиляции; используйте fmod() из math.h.

Присваивание и составное присваивание

= сохраняет значение. Составные формы объединяют операцию с сохранением:

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5 означает x = x + 5, но вычисляет x только один раз — что важно, когда целью является что-то вроде arr[compute_index()].

Присваивание само по себе является выражением, возвращающим присвоенное значение, — именно поэтому работает a = b = c = 0 (присваивание идёт справа налево) и поэтому ошибка = вместо == компилируется молча.

Инкремент и декремент

++ прибавляет единицу, -- вычитает единицу. У каждого есть префиксная и постфиксная форма:

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a получает 5 (старое значение), затем i становится 6 */
    printf("postfix: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* сначала j становится 6, затем b получает 6 */
    printf("prefix:  b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* как отдельная инструкция - идентично ++k */
    printf("statement: k = %d\n", k);
    return 0;
}

Как отдельная инструкция обе формы взаимозаменяемы, а i++ — общепринятый выбор в заголовке for без более глубокой причины, чем традиция.

Чего делать нельзя — так это использовать переменную больше одного раза в выражении, где она также изменяется:

int i = 5;
int x = i++ + i++;      /* неопределённое поведение */
arr[i] = i++;           /* неопределённое поведение */
printf("%d %d", i++, i);/* неопределённое поведение */

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

Операторы сравнения

Их шесть, и все они дают int: 1 для истины и 0 для лжи.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

То, что результатом является обычный int, а не отдельный логический тип, — определяющая черта C; см. логический тип в C, чтобы понять, что из этого следует, включая баг = вместо ==.

Две ошибки сравнения специфичны для C. Цепочки не работают так, как подсказывает математика: if (1 < x < 10) всегда истинно, потому что 1 < x даёт 0 или 1, а затем это сравнивается с 10. Пишите if (x > 1 && x < 10). И сравнение строк через == сравнивает указатели, а не текст — используйте strcmp из string.h.

Логические операторы

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("Может водить\n");
    }

    if (age < 13 || age > 65) {
        printf("Билет со скидкой\n");
    } else {
        printf("Полная цена\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&& — это И, || — ИЛИ, ! — НЕ. Все три считают истиной любое ненулевое значение.

Они вычисляются лениво: && останавливается, как только один операнд оказывается ложным, а || — как только один оказывается истинным. Остальное никогда не вычисляется, и это не просто оптимизация — это гарантия, на которую можно опереться ради безопасности:

#include <stdio.h>

int is_safe(int *p) {
    /* Если p равен NULL, *p никогда не вычисляется - && останавливается раньше. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("с настоящим указателем: %d\n", is_safe(&value));
    printf("с NULL:                 %d\n", is_safe(NULL));
    return 0;
}

Поменяйте эти две проверки местами — и вызов с NULL разыменует нулевой указатель и уронит программу. Сначала проверка, потом использование — порядок в цепочке && является частью логики.

Условный оператор

Единственный трёхместный оператор C выбирает между двумя значениями:

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("max = %d\n", max);

    printf("%d элемент%s\n", a, (a == 1) ? "" : "ов");
    return 0;
}

условие ? значение_если_истина : значение_если_ложь. Это выражение, поэтому оно помещается там, где инструкция if не может: внутри аргумента printf, в инициализаторе. Держите его коротким; вложенные условные операторы быстро становятся нечитаемыми.

Побитовые операторы, коротко

Они работают с отдельными битами целого числа:

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 1100 в двоичной системе */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, И */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, ИЛИ */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, исключающее ИЛИ */
    printf("~a     = %u\n", ~a);       /* НЕ - инвертирует каждый бит */
    printf("a << 2 = %u\n", a << 2);   /* 48 - сдвиг влево, умножает на 4 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - сдвиг вправо, делит на 4 */
    return 0;
}

Их применяют для флагов, масок и аппаратных регистров. Две предосторожности: & и | — это не && и || (они не вычисляются лениво и работают побитово), а сдвиг знакового значения или сдвиг больше ширины типа не определён. Для работы с битами используйте беззнаковые типы.

Приоритет

Когда в выражении нет скобок, эта таблица решает, что с чем связывается. Наивысший приоритет — первым:

Практические следствия:

a + b * c       /* означает a + (b * c) */
a < b == c < d  /* означает (a < b) == (c < d) - редко то, что вы имели в виду */
x & 1 == 0      /* означает x & (1 == 0), то есть x & 0 - классический баг */
*p++            /* означает *(p++) - разыменовать p, затем сдвинуть его */

Третью строку стоит запомнить: == связывается сильнее, чем &, поэтому проверкам битовых масок нужны скобки — (x & 1) == 0.

Никто не помнит все пятнадцать уровней, и никому это не нужно. Выучите, что * сильнее +, что сравнения сильнее &&, а && сильнее ||, а всё остальное получает скобки:

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

В этой строке есть избыточные скобки, и она от этого только лучше.