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;
}
В этом примере:
a + b— сложение;a / b— целочисленное деление;a % b— остаток от деления;a > bиa == b— операции отношения;(double)a— явное приведение типа;a += 5— составное присваивание;b++— постфиксный инкремент.
Что нужно запомнить
- Операции используются для построения выражений.
- Приоритет определяет, какая операция выполняется раньше.
- Ассоциативность определяет направление вычисления операций одного приоритета.
- Скобки помогают явно задать нужный порядок вычислений.
- Унарные операции имеют один операнд, бинарные — два, тернарная — три.
++и--бывают префиксными и постфиксными.sizeofвозвращает размер типа или объекта в байтах.- При делении целых чисел получается целый результат.
%возвращает остаток от целочисленного деления.- Операции отношения возвращают
0или1. =— присваивание,==— сравнение.- Логические операции
&&и||могут вычисляться сокращённо. - Тернарная операция выбирает одно из двух значений по условию.
- Приведение типа позволяет явно изменить тип значения.
Самопроверка перед переходом дальше
- Что такое операция и операнд?
- Чем унарная операция отличается от бинарной?
- Что такое приоритет операции?
- Зачем нужна ассоциативность?
- Почему выражение
2 + 3 * 4равно14? - Чем отличается
i++от++i? - Почему
5 / 2даёт2? - Для чего нужна операция
%? - Чем отличается
=от==? - Что делает операция
sizeof? - Как работает тернарная операция
?:? - Зачем нужно явное приведение типа?