1.4. Операции

Теория

Зачем нужен этот пункт

Операции в языке C используются для построения выражений. С их помощью можно складывать числа, сравнивать значения, изменять переменные, работать с битами, получать адреса, обращаться к объектам по указателям и выполнять другие действия.

Важно понимать не только смысл отдельной операции, но и её приоритет и ассоциативность. Именно они определяют, в каком порядке будет вычислено выражение.

int result = 2 + 3 * 4;

Здесь сначала выполнится умножение, а потом сложение. Поэтому результат будет 14, а не 20.

Операция, операнд и выражение

Операция — это действие, которое выполняется над одним, двумя или тремя значениями.

Операнд — это значение, переменная или выражение, к которому применяется операция.

a + b

Здесь + — операция сложения, а a и b — операнды.

По количеству операндов операции делятся на:

-x              /* унарная операция */
a + b           /* бинарная операция */
x > 0 ? x : -x  /* тернарная операция */

Приоритет и ассоциативность

Приоритет показывает, какая операция выполняется раньше, если в выражении есть несколько операций.

2 + 3 * 4

Операция умножения имеет более высокий приоритет, чем сложение, поэтому сначала вычисляется 3 * 4, а затем результат прибавляется к 2.

Ассоциативность показывает направление вычисления операций одного приоритета: слева направо или справа налево.

10 - 3 - 2

Операция вычитания выполняется слева направо:

(10 - 3) - 2 = 5

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

(2 + 3) * 4

Здесь сначала выполнится сложение, затем умножение. Результат будет 20.

Таблица приоритетов операций

Чем меньше номер ранга, тем выше приоритет операции. Операции одного ранга имеют одинаковый приоритет и выполняются с учётом ассоциативности.

Ранг Операции Ассоциативность
1 () [] -> . слева направо
2 ! ~ + - ++ -- & * (тип) sizeof справа налево
3 * / % слева направо
4 + - слева направо
5 << >> слева направо
6 < <= >= > слева направо
7 == != слева направо
8 & слева направо
9 ^ слева направо
10 | слева направо
11 && слева направо
12 || слева направо
13 ?: справа налево
14 = *= /= %= += -= &= ^= |= <<= >>= справа налево
15 , слева направо

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

Один знак — разные операции

В языке C один и тот же символ может обозначать разные операции. Смысл определяется по контексту.

int a = 10;
int b = -a;     /* унарный минус */

int c = a - 5;  /* бинарный минус */

Символ * тоже имеет несколько значений:

int result = a * b;  /* умножение */

int *ptr;            /* объявление указателя */
value = *ptr;        /* разыменование указателя */

Символ & может означать получение адреса или поразрядное И:

int *p = &a;    /* получение адреса */

int x = a & b;  /* поразрядное И */

Унарные операции

Унарные операции применяются к одному операнду.

Операция Назначение Пример
& получение адреса объекта &x
* обращение по адресу, разыменование *p
- изменение знака -x
+ унарный плюс +x
~ поразрядное отрицание ~x
! логическое отрицание !x
++ увеличение на 1 ++x, x++
-- уменьшение на 1 --x, x--
sizeof размер объекта или типа в байтах sizeof(int)
(тип) явное приведение типа (double)x

Унарный плюс и унарный минус

Унарный минус меняет знак арифметического значения:

int x = 10;
int y = -x;   /* y = -10 */

Унарный плюс обычно не меняет значение. Он существует для симметрии с унарным минусом и используется редко.

int x = +10;

Важно отличать унарный минус от бинарного вычитания:

-x      /* один операнд */
a - b   /* два операнда */

Логическое отрицание !

Операция ! превращает истинное значение в ложное, а ложное — в истинное.

В языке C ложью считается 0, а любое ненулевое значение считается истиной.

!0      /* результат 1 */
!1      /* результат 0 */
!2      /* результат 0 */
!(-5)   /* результат 0 */

Операция ! часто используется в условиях:

if (!isReady)
{
    printf("Not ready");
}

Это читается как: «если не готово».

Поразрядное отрицание ~

Операция ~ работает с битовым представлением целого числа. Она заменяет каждый бит на противоположный: 0 становится 1, а 1 становится 0.

unsigned char x = 0b00001111;
unsigned char y = ~x;

Упрощённо:

x: 00001111
y: 11110000

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

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

Операция ++ увеличивает значение переменной на единицу. Операция -- уменьшает значение переменной на единицу.

i++;
i--;

++i;
--i;

У этих операций есть две формы: префиксная и постфиксная.

Префиксная форма

В префиксной форме значение сначала изменяется, а потом используется.

int n = 4;
int result = ++n * 2;

Сначала n станет равно 5, потом вычислится 5 * 2. Значение result будет 10.

Постфиксная форма

В постфиксной форме сначала используется старое значение, а изменение происходит после этого.

int n = 4;
int result = n++ * 2;

В выражении используется старое значение n, то есть 4. Поэтому result будет 8, а после вычисления n станет равно 5.

К чему можно применять ++ и --

Операции ++ и -- можно применять только к изменяемым объектам, то есть к таким выражениям, которые обозначают область памяти, значение которой можно изменить.

Правильно:

int i = 0;
i++;
++i;

Ошибочно:

++5;
84++;
++(a + b);

Числовая константа не является изменяемой областью памяти. Выражение a + b тоже не является отдельной переменной, которую можно увеличить на единицу.

Операция sizeof

Операция sizeof возвращает размер объекта или типа в байтах.

sizeof выражение
sizeof(тип)

Примеры:

int x = 10;

sizeof x;
sizeof(int);
sizeof(double);

Результат зависит от компилятора и платформы. Например, на одной системе sizeof(int) может быть равен 4, а на другой — другому значению.

Важная особенность: sizeof определяет размер по типу выражения. Само выражение обычно не вычисляется как обычное выражение.

int i = 10;
sizeof(i++);

Такая запись не должна использоваться как способ увеличить i. sizeof нужен для определения размера, а не для выполнения побочных действий.

Бинарные операции

Бинарные операции имеют два операнда. В языке C их удобно разделить на несколько групп:

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

Основные арифметические операции:

Операция Назначение Пример
+ сложение a + b
- вычитание a - b
* умножение a * b
/ деление a / b
% остаток от деления a % b

Операции *, /, % имеют более высокий приоритет, чем + и -.

2 + 3 * 4   /* 14 */
(2 + 3) * 4 /* 20 */

Целочисленное деление

Если оба операнда операции / являются целыми числами, результат тоже будет целым. Дробная часть отбрасывается.

20 / 3    /* 6 */
5 / 2     /* 2 */

Если нужен вещественный результат, хотя бы один операнд должен быть вещественным.

5 / 2       /* 2 */
5.0 / 2     /* 2.5 */
5 / 2.0     /* 2.5 */

Это одна из частых ошибок начинающих: ожидать от 5 / 2 результат 2.5.

Остаток от деления %

Операция % возвращает остаток от целочисленного деления.

13 % 4   /* 1 */
10 % 2   /* 0 */
11 % 2   /* 1 */

Операция % применяется только к целочисленным операндам.

10 % 3      /* правильно */
10.5 % 3    /* ошибка */

С помощью % удобно проверять делимость и чётность числа.

if (number % 2 == 0)
{
    printf("Число чётное");
}

Для целых чисел при ненулевом делителе выполняется связь:

(a / b) * b + a % b == a

Операции сдвига

Операции сдвига работают с битовым представлением целочисленных значений.

Операция Назначение Пример
<< сдвиг влево x << 2
>> сдвиг вправо x >> 1

Левый операнд — число, битовое представление которого сдвигается. Правый операнд — количество позиций сдвига.

4 << 2   /* 16 */
5 >> 1   /* 2 */

В двоичном виде:

4:       100
4 << 2: 10000  /* 16 */

5:      101
5 >> 1: 10     /* 2 */

Для неотрицательных чисел сдвиг влево на n позиций часто соответствует умножению на 2^n, а сдвиг вправо — делению на 2^n с отбрасыванием дробной части.

Поразрядные операции

Поразрядные операции обрабатывают целые значения на уровне отдельных битов.

Операция Название Пример
& поразрядное И a & b
| поразрядное ИЛИ a | b
^ поразрядное исключающее ИЛИ a ^ b
~ поразрядное НЕ ~a

Примеры:

6 & 5   /* 4 */
6 | 5   /* 7 */
6 ^ 5   /* 3 */

Пояснение в двоичном виде:

6 = 110
5 = 101

6 & 5 = 100  /* 4 */
6 | 5 = 111  /* 7 */
6 ^ 5 = 011  /* 3 */

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

Поразрядное И, ИЛИ и исключающее ИЛИ

Поразрядное И: &

Результирующий бит равен 1 только тогда, когда оба соответствующих бита равны 1.

  110
& 101
  ---
  100

Поразрядное ИЛИ: |

Результирующий бит равен 1, если хотя бы один из соответствующих битов равен 1.

  110
| 101
  ---
  111

Исключающее ИЛИ: ^

Результирующий бит равен 1, если соответствующие биты различны.

  110
^ 101
  ---
  011

Операции отношения

Операции отношения сравнивают два значения. Результатом является целое значение: 1, если отношение истинно, и 0, если оно ложно.

Операция Смысл
< меньше
<= меньше или равно
> больше
>= больше или равно
== равно
!= не равно
3 < 5    /* 1 */
3 > 5    /* 0 */
3 == 5   /* 0 */
3 != 5   /* 1 */

Важно не путать = и ==.

x = 5;    /* присваивание */
x == 5;   /* сравнение */

Логические операции

Логические операции используются для объединения условий.

Операция Название Пример
! логическое НЕ !x
&& логическое И a > 0 && b > 0
|| логическое ИЛИ a == 0 || b == 0

Результат логической операции — 0 или 1.

3 != 5 || 3 == 5   /* 1 */

Пример проверки сторон треугольника:

if (a + b > c && a + c > b && b + c > a)
{
    printf("Треугольник существует");
}

Короткое вычисление логических выражений

В C логические операции && и || вычисляются с сокращением.

Для &&: если левая часть ложна, правая часть уже не вычисляется.

if (x != 0 && 10 / x > 1)
{
    printf("OK");
}

Здесь деление выполняется только если x != 0. Это защищает от деления на ноль.

Для ||: если левая часть истинна, правая часть уже не вычисляется.

if (isReady || checkData())
{
    printf("Можно продолжать");
}

Если isReady истинно, функция checkData() не вызывается.

Операции присваивания

Операция присваивания записывает значение правого выражения в объект, указанный слева.

x = 10;

Слева должен находиться изменяемый объект, например переменная.

int x;
x = 10;   /* правильно */

10 = x;   /* ошибка */

Операции присваивания имеют низкий приоритет и выполняются справа налево.

a = b = c = 0;

Сначала c получает 0, затем b, затем a.

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

Составные операции присваивания совмещают обычную операцию и присваивание.

Запись Эквивалент
x += 2 x = x + 2
x -= 2 x = x - 2
x *= 2 x = x * 2
x /= 2 x = x / 2
x %= 2 x = x % 2
x <<= 1 x = x << 1
x >>= 1 x = x >> 1
x &= mask x = x & mask
x |= mask x = x | mask
x ^= mask x = x ^ mask

Составная запись короче и часто читается лучше:

sum += value;
count++;
number *= 2;

Операции выбора компонентов: . и ->

Операции . и -> используются при работе со структурами и объединениями.

Операция . выбирает поле объекта структуры.

student.age

Операция -> выбирает поле структуры через указатель.

studentPtr->age

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

Скобки как операции

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

printf("Hello");
sqrt(x);

Квадратные скобки используются для обращения к элементу массива:

array[0]
matrix[i][j]

Вызов функции и индексирование имеют высокий приоритет.

Операция «запятая»

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

int x;
int y;

y = (x = 3, x * 2);

Здесь сначала x получает значение 3, затем вычисляется x * 2. В итоге y будет равно 6.

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

На практике операция «запятая» часто встречается в заголовке цикла for:

for (i = 0, j = 10; i < j; i++, j--)
{
    printf("%d %d\n", i, j);
}

Тернарная условная операция

Тернарная операция — единственная операция C с тремя операндами. Она записывается с помощью ? и :.

условие ? выражение_если_истина : выражение_если_ложь

Сначала вычисляется условие. Если оно истинно, результатом становится второе выражение. Если ложно — третье.

int absValue = x < 0 ? -x : x;

Если x меньше нуля, берётся -x. Иначе берётся само x.

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

Плохо читается:

result = a > b ? a > c ? a : c : b > c ? b : c;

Лучше заменить сложную запись обычным if.

Явное приведение типа

Операция приведения типа позволяет явно преобразовать значение к нужному типу.

(тип) операнд

Примеры:

int a = 5;
int b = 2;

double result = (double)a / b;

Без приведения a / b дало бы целочисленный результат 2. Благодаря (double)a деление становится вещественным, и результат будет 2.5.

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

int x = (int)3.99;  /* x = 3 */

Неоднозначные на вид выражения

Иногда выражение выглядит странно из-за соседства нескольких знаков. Компилятор всё равно разбирает его по правилам лексического анализа и приоритетов.

x+++b

Такая запись воспринимается как:

(x++) + b

Ещё пример:

z---d

Такая запись воспринимается как:

(z--) - d

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

x++ + b;
z-- - d;

Типичные ошибки

Ошибка 1. Путаница = и ==

if (x = 5)
{
    printf("x равен 5");
}

Здесь выполняется присваивание, а не сравнение. Правильно:

if (x == 5)
{
    printf("x равен 5");
}

Ошибка 2. Ожидание вещественного результата от целочисленного деления

double x = 5 / 2;   /* x получит 2.0 */

Правильно:

double x = 5.0 / 2;

Ошибка 3. Использование % для вещественных чисел

double r = 10.5 % 3;  /* ошибка */

Операция % работает только с целыми числами.

Ошибка 4. Слишком сложные выражения с ++ и --

a = i++ + ++i;

Такие выражения трудно читать и легко ошибиться. Лучше разбивать действия на несколько строк.

i++;
++i;
a = i;

Ошибка 5. Отсутствие скобок там, где они улучшают понимание

if (a + b > c && a + c > b || debugMode)

Приоритеты определят порядок вычисления, но человеку читать сложно. Лучше добавить скобки:

if ((a + b > c && a + c > b) || debugMode)

Мини-разбор фрагмента программы

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = 3;

    printf("a + b = %d\n", a + b);
    printf("a / b = %d\n", a / b);
    printf("a %% b = %d\n", a % b);

    printf("a > b = %d\n", a > b);
    printf("a == b = %d\n", a == b);

    printf("double division = %.2f\n", (double)a / b);

    a += 5;
    b++;

    printf("a = %d\n", a);
    printf("b = %d\n", b);

    return 0;
}

В этом примере:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое операция и операнд?
  2. Чем унарная операция отличается от бинарной?
  3. Что такое приоритет операции?
  4. Зачем нужна ассоциативность?
  5. Почему выражение 2 + 3 * 4 равно 14?
  6. Чем отличается i++ от ++i?
  7. Почему 5 / 2 даёт 2?
  8. Для чего нужна операция %?
  9. Чем отличается = от ==?
  10. Что делает операция sizeof?
  11. Как работает тернарная операция ?:?
  12. Зачем нужно явное приведение типа?