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 };
Разберём этот пример:
- первый элемент массива получает текущее значение
i, то есть1; - во втором элементе сначала выполняется
i = 2, затем вычисляетсяi * i; - третий элемент получает уже изменённое значение
i, то есть2.
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;
}
В этом фрагменте используются разные разделители:
#— начало директив#includeи#define;( )— параметры функцииmain, вызовprintf, заголовокfor;{ }— тело функции, тело цикла и список инициализации массива;[ ]— размер массива и обращение к элементуnumbers[i];,— разделение элементов списка инициализации и переменных;;— завершение объявлений и операторов;=— инициализация и присваивание.
Что нужно запомнить
- Разделители помогают задавать структуру программы.
[ ]используются для массивов и индексов.( )используются в условиях, функциях, циклах и выражениях.{ }ограничивают блоки кода и списки инициализации.,может быть разделителем списка или операцией.;завершает оператор, объявление или определение.- Одинокая
;является пустым оператором. :используется после меток,caseиdefault....обозначает переменное число аргументов функции.*может означать умножение, указатель или разыменование.=используется для инициализации и присваивания, а==— для сравнения.#используется в директивах препроцессора.
Самопроверка перед переходом дальше
- Для чего используются квадратные скобки?
- Зачем в условном операторе нужны круглые скобки?
- Почему после тела функции не ставят точку с запятой?
- Почему после определения структуры точка с запятой нужна?
- Чем запятая-разделитель отличается от запятой-операции?
- Что такое пустой оператор?
- Почему опасна лишняя точка с запятой после
if? - Где используется многоточие
...? - Какие разные значения может иметь символ
*? - Для чего используется символ
#?