1.5. Разделители

Теория

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

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

Часть разделителей уже встречалась в предыдущих пунктах: ; завершала объявления, { } ограничивали тело функции, ( ) использовались в вызове функции, а , разделяла элементы списков.

Важно понимать: один и тот же символ в языке C может иметь разное назначение в зависимости от контекста. Например, * может быть знаком умножения, знаком разыменования указателя или частью объявления указателя.

Основные разделители языка C

К разделителям, или знакам пунктуации, относятся:

[ ]  ( )  { }  ,  ;  :  ...  *  =  #

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

Разделитель Основное назначение
[ ] индексы массивов
( ) условия, параметры функций, группировка выражений
{ } блоки кода, тела функций, инициализация списком
, разделение элементов списков
; завершение оператора, объявления или определения
: метки, варианты case и default
... переменное число аргументов функции
* указатели и операции с указателями
= инициализация и присваивание
# директивы препроцессора

Квадратные скобки [ ]

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

Объявление массива

int A[5];

Здесь объявлен массив A из пяти элементов типа int.

Обращение к элементу массива

A[0] = 10;
A[1] = 20;

В C индексация массивов начинается с нуля. Поэтому первый элемент массива имеет индекс 0, второй — 1, и так далее.

Многомерные массивы

int matrix[3][2];

Здесь объявлен двумерный массив: 3 строки и 2 столбца.

matrix[0][0] = 5;
matrix[2][1] = 9;

Каждая пара квадратных скобок задаёт отдельный индекс.

Круглые скобки ( )

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

1. Условия в операторах

В условном операторе if условие обязательно записывается в круглых скобках.

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

Выражение x < 0 является условием. Если оно истинно, выполняется тело оператора.

2. Параметры функции

В определении функции круглые скобки ограничивают список параметров.

float F(float x, int k)
{
    return x + k;
}

В прототипе функции круглые скобки ограничивают список спецификаций параметров.

float F(float, int);

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

При вызове функции в круглых скобках указываются аргументы.

printf("Hello");
F(3.5f, 2);

Даже если у функции нет параметров, круглые скобки всё равно нужны.

getchar();

4. Группировка выражений

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

y = (a + b) / c;

Без скобок сначала выполнилось бы деление b / c, а затем сложение. Со скобками сначала вычисляется a + b.

5. Операторы циклов

В циклах for, while и do while круглые скобки ограничивают условие или управляющие части цикла.

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

while (i < j)
{
    i++;
}

do
{
    k--;
} while (k > 0);

6. Указатель на функцию

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

int (*pfunc)(void);

Здесь pfunc — указатель на функцию, которая не принимает параметров и возвращает int.

7. Макроопределения

В макросах круглые скобки помогают избежать ошибок из-за приоритетов операций.

Плохой вариант:

#define SQUARE(x) x * x

Если вызвать такой макрос как SQUARE(a + b), получится не то, что ожидается:

a + b * a + b

Лучше писать так:

#define SQUARE(x) ((x) * (x))

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

Фигурные скобки { }

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

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

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

if (d > x)
{
    d--;
    x++;
}

Здесь при истинном условии выполняются оба действия: d-- и x++.

Тело функции

Тело любой функции записывается в фигурных скобках.

float absx(float x)
{
    return x > 0.0 ? x : -x;
}

После закрывающей фигурной скобки тела функции точка с запятой не ставится.

Важное отличие

int main(void)
{
    return 0;
}   /* после этой скобки ; не нужна */

Фигурная скобка закрывает тело функции. Это не объявление переменной и не оператор-выражение, поэтому точка с запятой после неё не требуется.

Структуры и объединения

В определениях структур и объединений фигурные скобки ограничивают список компонентов.

struct cell
{
    char *b;
    int ee;
    double U[6];
};

union mix
{
    unsigned int ii;
    char cc[2];
};

После определения структурного или объединяющего типа точка с запятой нужна. Это частая ошибка начинающих.

Инициализация массивов и структур

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

int month[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

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

struct mixture
{
    int ii;
    double dd;
    char cc;
};

struct mixture stock = { 666, 3.67, '\t' };

Значение 666 попадёт в поле ii, 3.67 — в поле dd, а '\t' — в поле cc.

Запятая

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

Запятая как разделитель

Как разделитель запятая отделяет элементы списков.

Например, список переменных одного типа:

int i, n;
float x, y, z, p1, p2;

Список аргументов функции:

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

Список параметров в определении функции:

int sum(int a, int b)
{
    return a + b;
}

Список начальных значений массива:

int numbers[] = { 1, 2, 3, 4, 5 };

Запятая в заголовке цикла for

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

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

В первой части цикла задаются начальные значения i и j. В третьей части цикла одновременно изменяются обе переменные.

Запятая как операция

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

int x;
int y;

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

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

Чтобы отделить запятую-операцию от запятой-разделителя, часто используют круглые скобки.

int i = 1;
int m[] = { i, (i = 2, i * i), i };

Разберём этот пример:

m[0] == 1
m[1] == 4
m[2] == 2

Точка с запятой ;

Точка с запятой завершает оператор, объявление или определение. Это один из самых важных разделителей в C.

int x;
x = 10;
printf("%d\n", x);

Каждая из этих строк заканчивается точкой с запятой.

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

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

i++;
F(z, 4);
x = x + 1;

В первом случае результатом является изменение переменной i. Во втором — выполняется вызов функции F. В третьем — переменной x присваивается новое значение.

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

Одинокая точка с запятой считается пустым оператором.

;

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

for (i = 0; i < 10; i++)
    ;

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

Опасная лишняя точка с запятой

Лишняя точка с запятой после if может полностью изменить смысл программы.

if (x > 0);
{
    printf("x is positive\n");
}

Здесь после if (x > 0) стоит пустой оператор. Блок ниже уже не является телом if и выполнится всегда.

Правильно:

if (x > 0)
{
    printf("x is positive\n");
}

Двоеточие :

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

label:
    printf("Метка достигнута\n");

Метка может использоваться вместе с оператором goto.

goto label;

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

Двоеточие в switch

Двоеточие также используется после меток case и default в операторе switch.

switch (command)
{
    case 1:
        printf("Start\n");
        break;

    case 2:
        printf("Stop\n");
        break;

    default:
        printf("Unknown command\n");
        break;
}

Здесь case 1:, case 2: и default: являются метками внутри переключателя.

Многоточие ...

Многоточие — это три точки подряд без пробелов:

...

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

int printf(const char *format, ...);
int scanf(const char *format, ...);

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

printf("Hello\n");
printf("x = %d\n", x);
printf("x = %d, y = %d\n", x, y);

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

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

Звёздочка *

Звёздочка может быть знаком операции и частью объявления указателя. Её значение зависит от контекста.

Умножение

result = a * b;

Здесь * — бинарная операция умножения.

Объявление указателя

int *p;

Здесь p — указатель на объект типа int. Звёздочка показывает, что объявляется не обычная переменная int, а указатель на int.

Разыменование указателя

value = *p;

Здесь *p означает получение значения объекта, на который указывает p.

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

Знак равенства =

Знак = часто воспринимается как операция присваивания, но он также участвует в синтаксисе объявлений с инициализацией.

Присваивание

x = 10;

Значение 10 записывается в переменную x.

Инициализация

int x = 10;
double pi = 3.14159;

Здесь знак = отделяет имя определяемого объекта от его начального значения.

Не путать с равенством

Для проверки равенства используется двойной знак ==.

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

Это одна из самых частых ошибок начинающих программистов на C.

Решётка #

Символ # используется в директивах препроцессора. Директивы препроцессора обрабатываются до основного этапа компиляции.

#include <stdio.h>
#define MAX_SIZE 100

Директива #include подключает содержимое заголовочного файла. Директива #define задаёт макроопределение или текстовую замену.

В отличие от обычных операторов, директивы препроцессора обычно не завершаются точкой с запятой.

#define PI 3.14159   /* правильно */
#define PI 3.14159;  /* обычно ошибка по смыслу */

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

Разделитель или операция: как отличать

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

Символ Как разделитель / часть конструкции Как операция
, int a, b; y = (x = 1, x + 2);
* int *p; a * b, *p
= int x = 10; x = 20;
( ) printf("Hi"); (a + b) * c

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

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

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

if (x > 0);
{
    printf("positive\n");
}

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

Ошибка 2. Забыли точку с запятой после объявления

int x
x = 10;

Правильно:

int x;
x = 10;

Ошибка 3. Поставили точку с запятой после тела функции

int main(void)
{
    return 0;
};

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

Ошибка 4. Забыли точку с запятой после структуры

struct Student
{
    int age;
}

Правильно:

struct Student
{
    int age;
};

Ошибка 5. Перепутали запятую-разделитель и запятую-операцию

int x = 1, y = 2;

Здесь запятая разделяет два объявления. А вот здесь запятая является операцией:

y = (x = 3, x + 1);

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

#include <stdio.h>

#define SIZE 5

int main(void)
{
    int numbers[SIZE] = { 1, 2, 3, 4, 5 };
    int i, sum = 0;

    for (i = 0; i < SIZE; i++)
    {
        sum += numbers[i];
    }

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

    return 0;
}

В этом фрагменте используются разные разделители:

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

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

  1. Для чего используются квадратные скобки?
  2. Зачем в условном операторе нужны круглые скобки?
  3. Почему после тела функции не ставят точку с запятой?
  4. Почему после определения структуры точка с запятой нужна?
  5. Чем запятая-разделитель отличается от запятой-операции?
  6. Что такое пустой оператор?
  7. Почему опасна лишняя точка с запятой после if?
  8. Где используется многоточие ...?
  9. Какие разные значения может иметь символ *?
  10. Для чего используется символ #?