2.2. Элементарные средства программирования

Теория

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

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

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

В этом пункте рассматриваются:

Структура простой программы

Вернёмся к общей структуре простой программы, состоящей из одной функции main.

#include <stdio.h>

int main(void)
{
    определения_объектов;
    операторы;

    return 0;
}

На этом этапе в качестве директивы препроцессора чаще всего используется #include, а в качестве определяемых объектов — переменные и константы базовых типов.

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

Что такое оператор

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

В отличие от выражения, оператор сам по себе не рассматривается как значение. Он нужен для выполнения действия: изменить переменную, вызвать функцию, проверить условие, выполнить переход, завершить функцию.

x = 10;             /* оператор присваивания */
printf("%d\n", x);  /* оператор-вызов функции */
return 0;           /* оператор возврата */

Многие операторы строятся из выражений. Например, выражение x = 10 становится оператором, когда после него ставится точка с запятой:

x = 10;

Две большие группы операторов

По характеру действия операторы удобно разделить на две большие группы:

  1. операторы преобразования данных;
  2. операторы управления работой программы.

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

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

Операторы преобразования данных

К наиболее типичным операторам преобразования данных относятся:

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

i = x - 4 * i;

Здесь справа вычисляется выражение, затем результат записывается в переменную i.

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

x *= i;

Эта запись похожа на:

x = x * i;

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

Оператор-выражение

i++;

Здесь выражение i++ используется как самостоятельный оператор. Его главная цель — увеличить значение переменной i на единицу.

Вызов функции

printf("Hello\n");

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

Функция printf как оператор вывода

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

int age = 18;
double mark = 4.75;

printf("age = %d\n", age);
printf("mark = %.2f\n", mark);

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

Операторы управления программой

Операторы управления определяют, в каком порядке будут выполняться другие операторы.

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

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

Составной оператор

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

{
    n++;
    summa += (float)n;
}

Составной оператор позволяет использовать несколько операторов там, где синтаксически ожидается один оператор.

Например, если после if нужно выполнить не одно действие, а несколько, эти действия объединяются фигурными скобками:

if (x < 0)
{
    x = -x;
    printf("Знак числа изменён\n");
}

Блок

Блок похож на составной оператор: он тоже заключается в фигурные скобки. Отличие в том, что внутри блока могут быть объявления переменных.

{
    int n = 0;

    n++;
    summa += (float)n;
}

Переменная n, объявленная внутри блока, существует только внутри этого блока. За пределами блока она недоступна.

int main(void)
{
    int x = 10;

    {
        int y = 20;
        printf("%d\n", y);
    }

    printf("%d\n", x);
    /* printf("%d\n", y);  ошибка: y здесь уже недоступна */

    return 0;
}

Тело функции main тоже является блоком.

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

Условный оператор позволяет выполнить действие только при выполнении некоторого условия.

Сокращённая форма условного оператора:

if (выражение_условие)
    оператор;

Если выражение-условие истинно, оператор выполняется. Если условие ложно, оператор пропускается.

if (x < 0)
    x = -x;

В этом примере значение x меняет знак только тогда, когда x меньше нуля.

Что считается истиной и ложью

В языке C условие — это выражение. Его значение интерпретируется так:

if (5)
{
    printf("Это выполнится\n");
}

if (0)
{
    printf("Это не выполнится\n");
}

Обычно в условиях используют отношения и логические выражения:

if (x < 0)
{
    x = -x;
}

if (x > 0 && x < 10)
{
    printf("x находится в диапазоне от 1 до 9\n");
}

Для учебного кода лучше писать условия явно: x != 0, count > 0, value == 10. Так программа читается понятнее.

Полная форма if ... else

Полная форма условного оператора позволяет выбрать одно из двух действий.

if (выражение_условие)
    оператор_1;
else
    оператор_2;

Если условие истинно, выполняется оператор_1. Если условие ложно, выполняется оператор_2.

if (x > 0)
    b = x;
else
    b = -x;

Этот фрагмент записывает в b абсолютное значение x. Если x положительно, берётся само x. Если x отрицательно или равно нулю, берётся -x.

Фигурные скобки в if

Если в ветви if или else нужно выполнить несколько операторов, их обязательно объединяют в блок.

if (x < 0)
{
    x = -x;
    printf("Число было отрицательным\n");
}
else
{
    printf("Число не было отрицательным\n");
}

Хороший стиль — использовать фигурные скобки даже тогда, когда внутри ветви только один оператор. Это уменьшает риск ошибки при последующем редактировании программы.

if (count > 0)
{
    printf("Данные есть\n");
}

Вложенные условные операторы

Условные операторы можно вкладывать друг в друга. Это нужно, когда программа должна выбрать один вариант из нескольких.

if (x > 0)
{
    printf("Положительное число\n");
}
else
{
    if (x < 0)
    {
        printf("Отрицательное число\n");
    }
    else
    {
        printf("Ноль\n");
    }
}

Часто такую запись упрощают с помощью цепочки else if:

if (x > 0)
{
    printf("Положительное число\n");
}
else if (x < 0)
{
    printf("Отрицательное число\n");
}
else
{
    printf("Ноль\n");
}

Пример: проверка квадратного уравнения

Условный оператор часто используется для проверки возможности выполнения вычисления. Например, у квадратного уравнения ax² + bx + c = 0 действительные корни существуют только тогда, когда дискриминант неотрицателен.

#include <stdio.h>
#include <math.h>

int main(void)
{
    double a = 1.0;
    double b = -5.0;
    double c = 6.0;

    double d = b * b - 4.0 * a * c;
    double x1;
    double x2;

    if (d >= 0.0)
    {
        x1 = (-b + sqrt(d)) / (2.0 * a);
        x2 = (-b - sqrt(d)) / (2.0 * a);

        printf("x1 = %f\n", x1);
        printf("x2 = %f\n", x2);
    }
    else
    {
        printf("Действительных корней нет\n");
    }

    return 0;
}

Функция sqrt вычисляет квадратный корень. Для её использования подключается заголовочный файл math.h.

В этом примере после if используется составной оператор: при истинном условии нужно выполнить сразу несколько действий.

Пустой оператор

Пустой оператор состоит только из точки с запятой:

;

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

Иногда пустой оператор используют как место, куда можно поставить метку:

label:;

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

if (x > 0);
{
    printf("Этот блок выполнится всегда\n");
}

В этом примере после if стоит пустой оператор. Блок ниже уже не относится к условию и выполнится независимо от значения x.

Метки и оператор goto

Метка — это идентификатор, который ставится перед оператором и отделяется от него двоеточием.

start:
    printf("Начало\n");

Оператор goto выполняет безусловный переход к указанной метке.

goto start;

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

В большинстве учебных задач вместо goto лучше использовать:

Циклы будут изучаться в следующем пункте, поэтому сейчас достаточно понимать, что goto — это прямой переход к метке.

Ввод данных с клавиатуры

До этого программы могли использовать заранее заданные значения:

int a = 10;
int b = 20;

Но большинство программ должны получать исходные данные от пользователя. Для форматированного ввода в C используется функция scanf.

Для работы с scanf нужен заголовочный файл stdio.h, как и для printf.

#include <stdio.h>

Общий вид вызова:

scanf("форматная_строка", список_адресов);

Форматная строка указывает, какие данные нужно прочитать. А после неё передаются адреса переменных, куда нужно записать введённые значения.

Почему в scanf нужен символ &

Функция printf получает значения переменных:

printf("%d\n", n);

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

Адрес переменной получают с помощью унарной операции &.

&имя_переменной

Например:

int n;

scanf("%d", &n);

Здесь &n означает «адрес переменной n». Функция scanf считывает целое число и записывает его по этому адресу.

Простой пример scanf

#include <stdio.h>

int main(void)
{
    int n;
    float z;
    float x;

    printf("Введите целое число и два вещественных числа: ");
    scanf("%d%f%f", &n, &z, &x);

    printf("n = %d\n", n);
    printf("z = %f\n", z);
    printf("x = %f\n", x);

    return 0;
}

Если пользователь введёт:

18 18 -0.431

то переменная n получит значение 18, переменная z — значение 18.0, а переменная x — значение -0.431.

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

Спецификации преобразования scanf

Форматная строка scanf содержит спецификации преобразования, похожие на спецификации printf, но используются они для ввода, а не для вывода.

Спецификация Что вводит Типичная переменная
%d десятичное целое число int
%f вещественное число типа float float
%lf вещественное число типа double double
%c один символ char
%s строку без пробелов массив char

Для float при вводе используется %f, а для double — %lf. Это важное отличие от printf, где для вывода значения double обычно используется %f.

Пример ввода int и double

#include <stdio.h>

int main(void)
{
    int count;
    double price;

    printf("Введите количество: ");
    scanf("%d", &count);

    printf("Введите цену: ");
    scanf("%lf", &price);

    printf("Сумма = %.2f\n", count * price);

    return 0;
}

Здесь:

Возвращаемое значение scanf

Функция scanf возвращает количество успешно прочитанных и записанных значений.

int ret;
int n;
float x;

ret = scanf("%d%f", &n, &x);

Если пользователь корректно ввёл целое и вещественное число, ret получит значение 2.

Это можно использовать для проверки правильности ввода:

if (ret == 2)
{
    printf("Данные введены корректно\n");
}
else
{
    printf("Ошибка ввода\n");
}

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

Пропуск значения при вводе

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

scanf("%d %*s %c %s", &i, &c, s);

Здесь:

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

Ввод символов через scanf

При вводе символов нужно быть внимательным: спецификация %c читает ровно один следующий символ, в том числе пробел или символ перехода на новую строку.

char c;

scanf("%c", &c);

Если перед этим пользователь вводил число и нажимал Enter, во входном потоке мог остаться символ перехода на новую строку. Поэтому иногда перед %c ставят пробел в форматной строке:

scanf(" %c", &c);

Пробел перед %c говорит scanf пропустить пробельные символы перед чтением самого символа.

Ввод строк через scanf

Спецификация %s читает строку до первого пробельного символа.

char name[80];

scanf("%s", name);

Для массива символов при использовании %s обычно не пишут &, потому что имя массива в таком контексте уже указывает на область памяти, куда будут записаны символы.

Важно: %s не читает строку с пробелами. Если пользователь введёт:

Ivan Petrov

то %s прочитает только Ivan.

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

Мини-программа: ввод, вычисление и условие

Рассмотрим простую программу, которая вводит число, вычисляет его модуль и выводит результат.

#include <stdio.h>

int main(void)
{
    int x;
    int absValue;

    printf("Введите целое число: ");
    scanf("%d", &x);

    if (x < 0)
    {
        absValue = -x;
    }
    else
    {
        absValue = x;
    }

    printf("Модуль числа = %d\n", absValue);

    return 0;
}

В этой программе:

Мини-программа: проверка числа

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

#include <stdio.h>

int main(void)
{
    int x;

    printf("Введите число: ");
    scanf("%d", &x);

    if (x > 0)
    {
        printf("Число положительное\n");
    }
    else if (x < 0)
    {
        printf("Число отрицательное\n");
    }
    else
    {
        printf("Это ноль\n");
    }

    return 0;
}

Здесь используется цепочка if — else if — else. Такая форма удобна, когда нужно проверить несколько взаимоисключающих условий.

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

Ошибка 1. Забыли & в scanf

int x;

scanf("%d", x);   /* ошибка */

Нужно передать адрес переменной:

scanf("%d", &x);

Ошибка 2. Неверная спецификация для double

double x;

scanf("%f", &x);   /* ошибка для double */

Для ввода double используется %lf:

scanf("%lf", &x);

Ошибка 3. Присваивание вместо сравнения

if (x = 0)
{
    printf("x равен нулю\n");
}

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

if (x == 0)
{
    printf("x равен нулю\n");
}

Ошибка 4. Лишняя точка с запятой после if

if (x > 0);
{
    printf("Положительное число\n");
}

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

Ошибка 5. Отсутствие фигурных скобок при нескольких действиях

if (x < 0)
    x = -x;
    printf("Знак изменён\n");

В этом примере к if относится только строка x = -x;. Вызов printf выполнится всегда.

Правильно:

if (x < 0)
{
    x = -x;
    printf("Знак изменён\n");
}

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

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

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

  1. Что такое оператор?
  2. Чем оператор отличается от выражения?
  3. Какие две большие группы операторов можно выделить?
  4. Что такое составной оператор?
  5. Чем блок отличается от составного оператора?
  6. Как записывается сокращённая форма if?
  7. Как записывается полная форма if ... else?
  8. Какие значения считаются истинными и ложными в C?
  9. Почему опасна лишняя точка с запятой после if?
  10. Для чего в scanf нужен символ &?
  11. Чем отличается %f и %lf при вводе через scanf?
  12. Что возвращает функция scanf?