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

В этом выражении:

Поэтому выражение присваивания можно использовать внутри другого выражения, хотя делать это нужно аккуратно.

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;

Порядок выполнения такой:

  1. сначала вычисляется 4.0 + 2.4, получается 6.4;
  2. значение 6.4 присваивается переменной d;
  3. значение выражения d = 6.4 присваивается переменной x;
  4. значение выражения 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 */

Основные случаи преобразования типов

В базовом курсе нужно различать три основные ситуации:

  1. преобразования в арифметических выражениях;
  2. преобразования при присваивании;
  3. преобразования указателей.

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

Преобразования в арифметических выражениях

Если в арифметической операции участвуют операнды разных типов, компилятор обычно приводит их к общему типу. Как правило, более «узкий» тип преобразуется к более «широкому».

int a = 5;
double b = 2.0;

double result = a + b;

Перед сложением значение a преобразуется к типу double, затем выполняется сложение.

Упрощённый порядок для вещественных типов:

  1. если есть long double, второй операнд приводится к long double;
  2. иначе, если есть double, второй операнд приводится к double;
  3. иначе, если есть float, второй операнд приводится к float;
  4. иначе применяются правила для целых типов.

Целочисленные повышения

Перед выполнением многих арифметических операций короткие целые типы преобразуются к типу 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;
}

Разберём фрагмент:

После выполнения программы wrong будет равно 2.00, correct — 2.50, x — 15, а y — 10.

Практические рекомендации

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

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

  1. Что такое выражение?
  2. Чем выражение отличается от оператора?
  3. Почему z = 2.3 + 5.1 является выражением?
  4. Что получится при выполнении a = b = c = 0?
  5. Чем x += 5 похоже на x = x + 5?
  6. Что такое побочный эффект?
  7. Почему double x = 5 / 2; даёт 2.0, а не 2.5?
  8. Что делает явное приведение типа?
  9. Что происходит при присваивании double-значения переменной типа int?
  10. Какие значения считаются истинными и ложными в условиях языка C?