1.6. Выражения
Теория
Зачем нужен этот пункт
Выражения — одна из основных частей языка C. С их помощью программа вычисляет значения, сравнивает данные, изменяет переменные, вызывает функции и управляет ходом выполнения.
Выражение может быть очень простым, например одна переменная или одно число, а может состоять из множества операций.
5
x
x + 10
a + b > c
z = 2.3 + 5.1
Чтобы писать корректные программы, нужно понимать, как выражения вычисляются, какой тип имеет результат выражения и что происходит, если в одном выражении встречаются значения разных типов.
Что такое выражение
Выражение — это конструкция языка, которая после вычисления даёт некоторое значение. Это значение имеет определённый тип.
Примеры выражений:
10
3.14
x
x + y
x > 0
a = b + 1
У каждого выражения есть:
- значение — результат вычисления;
- тип — тип результата;
- иногда — побочный эффект, то есть изменение состояния программы.
Например:
x + 5
Это выражение вычисляет сумму, но само по себе не изменяет переменную
x.
x = x + 5
А это выражение не только вычисляет значение, но и изменяет переменную
x. Такое изменение называется побочным эффектом.
Простые и составные выражения
Простое выражение может состоять из одного литерала, переменной или вызова функции.
100
x
getchar()
Составное выражение строится из простых выражений с помощью операций.
a + b
(a + b) / c
x > 0 && y > 0
count = count + 1
Чем сложнее выражение, тем важнее помнить о приоритетах операций, ассоциативности и преобразовании типов.
Выражение и оператор
В языке C выражение само по себе ещё не обязательно является отдельной командой программы. Чтобы выражение стало оператором, после него часто ставят точку с запятой.
z = 2.3 + 5.1
Это выражение присваивания. Оно вычисляет значение 7.4 и
записывает его в переменную z.
z = 2.3 + 5.1;
А это уже оператор присваивания, потому что выражение завершено точкой с запятой.
Другие примеры операторов-выражений:
x++;
printf("Hello\n");
sum = sum + value;
Выражения без полезного результата
Некоторые выражения имеют значение, но в программе это значение не используется. Это нормально, если выражение выполняет полезное действие через побочный эффект.
printf("Hello\n");
Функция printf возвращает значение, но в учебных программах
его часто не используют. Главное действие здесь — вывод текста на экран.
x++;
Выражение x++ тоже имеет значение, но чаще его используют
ради изменения переменной x.
А вот такое выражение почти бесполезно:
x + 10;
Оно вычисляет сумму, но результат никуда не сохраняется и не используется.
Присваивание как выражение
В языке C присваивание — это операция, а не отдельная особая команда.
Поэтому конструкция с = является выражением.
z = 2.3 + 5.1
В этом выражении:
- справа вычисляется значение
2.3 + 5.1; - полученное значение присваивается переменной
z; - значением всего выражения становится присвоенное значение.
Поэтому выражение присваивания можно использовать внутри другого выражения, хотя делать это нужно аккуратно.
if ((x = getchar()) != '\n')
{
printf("Был введён не перевод строки");
}
Здесь сначала результат getchar() записывается в x,
а затем это значение сравнивается с '\n'.
Левая и правая часть присваивания
В операции присваивания слева должен находиться объект, значение которого можно изменить. На начальном этапе можно считать, что слева должна быть переменная.
Правильно:
x = 10;
sum = a + b;
Ошибочно:
10 = x;
a + b = 5;
Число 10 нельзя изменить. Выражение a + b тоже не
является отдельной переменной, в которую можно записать значение.
В дальнейшем, при изучении указателей и структур, появятся и другие допустимые левые части присваивания:
*p = 10;
student.age = 18;
array[i] = 5;
Множественное присваивание
Операция присваивания выполняется справа налево. Благодаря этому можно присвоить одно значение сразу нескольким переменным.
c = x = d = 4.0 + 2.4;
Порядок выполнения такой:
- сначала вычисляется
4.0 + 2.4, получается6.4; - значение
6.4присваивается переменнойd; - значение выражения
d = 6.4присваивается переменнойx; - значение выражения
x = dприсваивается переменнойc.
Такой приём удобно использовать для обнуления нескольких переменных:
a = b = c = 0;
Но если типы переменных разные, нужно помнить о преобразованиях типов.
Составные операции присваивания
Составные операции присваивания объединяют обычную операцию и присваивание.
| Запись | Похожая полная форма |
|---|---|
x += y |
x = x + y |
x -= y |
x = x - y |
x *= y |
x = x * y |
x /= y |
x = x / y |
x %= y |
x = x % y |
x &= y |
x = x & y |
x |= y |
x = x | y |
x ^= y |
x = x ^ y |
x <<= y |
x = x << y |
x >>= y |
x = x >> y |
Примеры:
sum += value;
count -= 1;
number *= 2;
mask |= flag;
В простых случаях составная запись короче и удобнее. Но если выражение сложное, лучше писать так, чтобы код оставался понятным.
Важная особенность составного присваивания
Записи x += y и x = x + y похожи по смыслу,
но в языке C они не всегда полностью одинаковы при сложных левых частях.
array[i] += 10;
Левая часть array[i] вычисляется как место, куда нужно
записать результат. В сложных выражениях это может быть важным.
На начальном этапе можно запомнить практическое правило: используйте составное присваивание для простых и понятных действий.
i += 1;
sum += value;
product *= factor;
Побочные эффекты
Побочный эффект — это изменение состояния программы во время вычисления выражения.
Выражения с побочными эффектами:
x = 10;
x++;
--count;
scanf("%d", &x);
В этих примерах изменяется значение переменной или состояние ввода.
Выражение без побочного эффекта:
x + 10
Оно вычисляет значение, но ничего не меняет.
Побочные эффекты полезны, но с ними легко сделать код непонятным.
Особенно осторожно нужно использовать ++, -- и
присваивание внутри сложных выражений.
Опасные сложные выражения
Начинающим лучше избегать выражений, где одна и та же переменная изменяется и читается несколько раз в одной строке.
Плохой стиль:
result = i++ + ++i;
Такое выражение трудно читать и легко неправильно понять. Лучше разбить его на несколько простых действий.
i++;
++i;
result = i;
Чем проще выражение, тем легче найти ошибку и объяснить работу программы.
Преобразование типов
В выражениях часто участвуют значения разных типов. Например:
int a = 5;
double b = 2.0;
double result = a / b;
Здесь в одном выражении участвуют int и double.
Чтобы выполнить операцию, компилятор приводит значения к совместимым
типам.
Преобразование типов может происходить:
- автоматически, то есть неявно;
- явно, если программист использует операцию приведения типа.
double x = 5; /* неявное преобразование int в double */
double y = (double)5; /* явное преобразование int в double */
Основные случаи преобразования типов
В базовом курсе нужно различать три основные ситуации:
- преобразования в арифметических выражениях;
- преобразования при присваивании;
- преобразования указателей.
Преобразования указателей рассматриваются позже, в главе про указатели. Сейчас важно понять арифметические преобразования и преобразования при присваивании.
Преобразования в арифметических выражениях
Если в арифметической операции участвуют операнды разных типов, компилятор обычно приводит их к общему типу. Как правило, более «узкий» тип преобразуется к более «широкому».
int a = 5;
double b = 2.0;
double result = a + b;
Перед сложением значение a преобразуется к типу
double, затем выполняется сложение.
Упрощённый порядок для вещественных типов:
- если есть
long double, второй операнд приводится кlong double; - иначе, если есть
double, второй операнд приводится кdouble; - иначе, если есть
float, второй операнд приводится кfloat; - иначе применяются правила для целых типов.
Целочисленные повышения
Перед выполнением многих арифметических операций короткие целые типы
преобразуются к типу int или более широкому типу.
| Исходный тип | Обычно преобразуется к |
|---|---|
char |
int |
signed char |
int |
unsigned char |
int или unsigned int |
short |
int |
unsigned short |
int или unsigned int |
enum |
int |
Например:
char a = 10;
char b = 20;
int result = a + b;
Перед сложением значения a и b обычно преобразуются
к int, а результат выражения тоже имеет тип int.
Упрощённая схема арифметических преобразований
Для большинства учебных задач можно пользоваться такой схемой:
char, short
↓
int
↓
unsigned int
↓
long
↓
unsigned long
↓
long long
↓
unsigned long long
↓
float
↓
double
↓
long double
Эта схема помогает понять общую идею: при смешивании типов значение часто поднимается к типу, который может представить более широкий диапазон или более высокую точность.
Но важно помнить: точные правила зависят от стандарта языка и реализации. Поэтому в важных вычислениях лучше явно выбирать подходящие типы.
Преобразования при присваивании
При присваивании значение правой части приводится к типу объекта в левой части.
int x;
double y = 3.8;
x = y;
Здесь значение 3.8 приводится к типу int.
Дробная часть отбрасывается, поэтому x получит значение
3.
Другой пример:
double d;
int i = 10;
d = i;
Здесь целое значение 10 преобразуется к double.
Такое преобразование обычно безопаснее, чем преобразование
double в int.
Потеря информации при преобразовании
Не каждое преобразование типов безопасно. Иногда при преобразовании теряется часть информации.
Вещественное число в целое
double x = 3.99;
int y = x;
В переменную y попадёт 3. Дробная часть будет
отброшена.
Большое число в маленький тип
int x = 1000;
char c = x;
Если тип char не может представить значение 1000,
результат будет зависеть от реализации. Такое преобразование опасно.
Целое число в вещественное
long long big = 9000000000000001LL;
double d = big;
Вещественный тип может не сохранить все младшие значащие цифры большого целого числа. Значение может быть округлено.
Безопасные и опасные преобразования
Условно безопасными можно считать преобразования, при которых значение сохраняется без изменения смысла и без потери точности.
Обычно безопаснее:
int → long
int → double
float → double
Может быть опасно:
double → int
long → short
int → char
unsigned int → int
long long → float
На практике нужно задавать себе вопрос:
Может ли значение исходного типа полностью поместиться в целевой тип без потери информации?
Если ответ «нет» или «не уверен», преобразование нужно делать осторожно.
Явное приведение типа
Явное приведение типа записывается в круглых скобках перед выражением.
(тип) выражение
Пример:
int a = 5;
int b = 2;
double result = (double)a / b;
Без приведения выражение a / b дало бы целочисленное значение
2. После приведения a к double деление
становится вещественным, и результат будет 2.5.
Явное приведение не делает опасное преобразование безопасным. Оно только показывает, что программист осознанно просит выполнить преобразование.
double x = 123456789.987;
int y = (int)x;
Здесь дробная часть всё равно будет отброшена.
Целочисленное и вещественное деление
Преобразования типов особенно часто проявляются при делении.
int a = 5;
int b = 2;
double x = a / b;
Несмотря на то что x имеет тип double, выражение
a / b сначала вычисляется как целочисленное деление.
Результатом будет 2, а затем это значение преобразуется
к 2.0.
Правильный вариант:
double x = (double)a / b;
Теперь один из операндов имеет тип double, поэтому выполняется
вещественное деление, и результат будет 2.5.
Выражения в условиях
В C условие — это тоже выражение. Если значение выражения равно
0, условие считается ложным. Любое ненулевое значение
считается истинным.
if (x)
{
printf("x не равен нулю");
}
Это эквивалентно:
if (x != 0)
{
printf("x не равен нулю");
}
Для ясности в учебных программах часто лучше писать условие явно:
if (count != 0)
{
printf("Есть элементы");
}
Логические выражения
Логические выражения используют операции !, &&
и ||.
a + b > c && a + c > b && b + c > a
Такое выражение можно использовать для проверки существования треугольника по трём сторонам.
Логические операции возвращают 0 или 1.
!5 /* 0 */
4 && 2 /* 1 */
0 || 7 /* 1 */
Операции && и || вычисляются сокращённо:
как только результат всего выражения становится известен, оставшаяся
часть может не вычисляться.
if (x != 0 && 10 / x > 1)
{
printf("OK");
}
Деление выполнится только если x != 0.
Выражения с запятой
Операция «запятая» вычисляет выражения слева направо. Результатом всего выражения становится значение последнего выражения.
int x;
int y;
y = (x = 3, x * 2);
Сначала x получает значение 3, затем вычисляется
x * 2. В итоге y получит 6.
Операцию «запятая» нужно отличать от запятой-разделителя.
int a, b, c; /* запятая-разделитель */
y = (x = 1, x + 2); /* запятая-операция */
Выражения с тернарной операцией
Тернарная операция позволяет выбрать одно из двух выражений по условию.
условие ? выражение_1 : выражение_2
Пример:
max = a > b ? a : b;
Если a > b истинно, переменная max получит
значение a. Иначе она получит значение b.
В простых случаях тернарная операция делает код компактным.
Но сложные вложенные тернарные выражения лучше заменять обычным
if, чтобы сохранить читаемость.
Порядок вычисления и скобки
Порядок вычисления выражения определяется приоритетом операций, ассоциативностью и скобками.
int result = 2 + 3 * 4;
Сначала выполняется умножение, поэтому результат равен 14.
int result = (2 + 3) * 4;
Здесь скобки меняют порядок вычислений, поэтому результат равен
20.
Если выражение становится трудно читать, лучше добавить скобки, даже если компилятор и без них вычислил бы всё правильно.
if ((a + b > c) && (a + c > b) && (b + c > a))
{
printf("Треугольник существует");
}
Типичные ошибки
Ошибка 1. Ожидание вещественного результата от целочисленного деления
int a = 5;
int b = 2;
double x = a / b; /* x будет 2.0, а не 2.5 */
Правильно:
double x = (double)a / b;
Ошибка 2. Потеря дробной части при присваивании
int x = 3.99;
Переменная x получит значение 3.
Ошибка 3. Использование присваивания вместо сравнения
if (x = 0)
{
printf("x равен нулю");
}
Здесь выполняется присваивание, а не сравнение.
Правильно:
if (x == 0)
{
printf("x равен нулю");
}
Ошибка 4. Слишком сложное выражение с побочными эффектами
result = i++ + ++i;
Такой код лучше не писать. Он плохо читается и может привести к ошибкам.
Ошибка 5. Неявное опасное преобразование
long value = 100000;
short small = value;
Если значение не помещается в short, результат может быть
неправильным.
Мини-разбор фрагмента программы
#include <stdio.h>
int main(void)
{
int a = 5;
int b = 2;
double wrong = a / b;
double correct = (double)a / b;
int x = 0;
int y = 0;
x = y = 10;
x += 5;
printf("wrong = %.2f\n", wrong);
printf("correct = %.2f\n", correct);
printf("x = %d\n", x);
printf("y = %d\n", y);
return 0;
}
Разберём фрагмент:
a / b— целочисленное деление, результат2;(double)a / b— вещественное деление, результат2.5;x = y = 10— множественное присваивание справа налево;x += 5— составное присваивание, то есть увеличениеxна 5;printf(...)— выражение-вызов функции, использованное как оператор.
После выполнения программы wrong будет равно 2.00,
correct — 2.50, x — 15,
а y — 10.
Практические рекомендации
- Не делайте выражения слишком длинными.
- Используйте скобки, если они улучшают читаемость.
- Не смешивайте много побочных эффектов в одной строке.
- Будьте осторожны с присваиванием внутри условия.
- Всегда помните разницу между
=и==. - При делении целых чисел явно приводите тип, если нужен вещественный результат.
- Проверяйте, не теряется ли информация при преобразовании типов.
Что нужно запомнить
- Выражение вычисляется и имеет значение.
- У выражения есть тип результата.
- Выражение с точкой с запятой может стать оператором-выражением.
- Присваивание в C является выражением.
- Значением выражения присваивания является присвоенное значение.
- Множественное присваивание выполняется справа налево.
- Составные присваивания сокращают записи вида
x = x + y. - Побочный эффект — это изменение состояния программы при вычислении выражения.
- При смешивании типов компилятор выполняет преобразования.
- При присваивании правая часть приводится к типу левой части.
- Преобразование
doubleвintотбрасывает дробную часть. - Для вещественного деления целых чисел нужно явно привести один операнд к вещественному типу.
- В условиях
0означает ложь, а любое ненулевое значение — истину.
Самопроверка перед переходом дальше
- Что такое выражение?
- Чем выражение отличается от оператора?
- Почему
z = 2.3 + 5.1является выражением? - Что получится при выполнении
a = b = c = 0? - Чем
x += 5похоже наx = x + 5? - Что такое побочный эффект?
- Почему
double x = 5 / 2;даёт2.0, а не2.5? - Что делает явное приведение типа?
- Что происходит при присваивании
double-значения переменной типаint? - Какие значения считаются истинными и ложными в условиях языка C?