- •1.1.Схема простой программы
- •1.2.Основы записи программ
- •1.2.1.Имена
- •1.2.2.Комментарии
- •1.2.3.Переменные и константы, объявления и присваивания
- •1.3.Основные конструкции: операторы, выражения, операции, операнды
- •2.1.Операторы объявления
- •2.2.“Линейные” операторы
- •2.3.Операторы управления программой
- •2.3.1.Условный оператор if (if-else)
- •2.3.2.Оператор выбора switch
- •2.3.3.Оператор цикла while
- •2.3.4.Оператор цикла do–while
- •2.3.5.Оператор цикла for
- •2.3.6.Операторы перехода break, continue и goto
- •3.1.Операция присваивания
- •3.2.Объединение действий с присваиванием
- •3.3.Операции увеличения и уменьшения на 1
- •3.4.Трактовка истинности
- •3.5.Операция ?
- •3.6.Операция «запятая»
- •3.7.Операция sizeof
- •4.1.Объявление, определение, параметры и вызов функции
- •4.2.Выход из функции
- •4.3.Организация памяти при выполнении программы
- •4.4.Правила видимости имен для функций
- •4.5.Одинаковое именование нескольких функций (перегрузка функций)
- •4.6.Параметры функций по умолчанию
- •4.7.Передача параметров функции по адресу
- •4.8.Библиотека стандартных функций
- •6.1.Целые числа
- •6.2.Вещественные числа
- •6.3.Логические значения
- •6.4.Символы
- •6.5.Преобразование типов
- •6.6.Вычисление значения выражения
- •7.1.Массивы
- •7.1.1.Одномерные массивы
- •7.1.2.Многомерные массивы
- •7.1.3.Строки
- •7.1.4.Массивы с неопределенным размером (безразмерные массивы)
- •7.2.Перечисления
4.1.Объявление, определение, параметры и вызов функции
Для того, чтобы использовать функции, необходимо сделать их известными в программе. Различают объявление и определение функции.
Предварительное объявление функции, часто называемое прототипом функции, сообщает компилятору тип возвращаемого функцией значения, имя функции и (в круглых скобках) список ее параметров и заканчивается точкой с запятой:
// Прототип функции func с одним целым параметром,
// возвращающей в качестве результата целое число:
int func (int a);
// Прототип функции s с двумя параметрами типа int,
// возвращающей результат типа double:
double s (int x, int y);
// Прототип функции f без параметров, возвращающей целое число:
int f ();
Такое объявление функции подобно объявлению переменной, оно определяет сигнатуру функции (ее имя, количество, типы и порядок параметров), а также тип возвращаемого значения. Имена параметров в прототипе функции избыточны и могут отсутствовать:
int func (int);
double s (int, int);
Определение функции описывает действия, выполняемые функцией для получения результата. Оно начинается заголовком, который указывает тип возвращаемого функцией значения, имя функции, список параметров функции и их типы. После заголовка в фигурных скобках записываются операторы (тело) функции – действия, которые данная функция выполняет. Пример определения функции, принимающей в качестве параметра значение типа int, вычисляющей и возвращающей его квадрат:
int func (int a) // заголовок функции
{
int sq = a * a; // тело функции...
return sq;
}
Параметры, указанные в заголовке функции называются формальными параметрами. При выполнении функции вместо них подставляются фактические параметры, указываемые при обращении к функции.
Для того, чтобы выполнить операторы функции, необходимо вызвать эту функцию (обратиться к ней), указав в нужной точке программы имя функции и следом в скобках – список фактических (передаваемых в функцию) параметров.
При вызове функции управление передается на ее начало и начинается выполнение ее операторов. Формальные параметры принимают значения фактических параметров, заданных при вызове, и функция выполняется в соответствии с ее определением. При достижении конца функции или оператора return происходит выход из функции, управление возвращается в ту точку, откуда функция была вызвана, а вместо имени функции подставляется вычисленный результат.
Несколько примеров использования определенной выше функции func, имеющей один параметр типа int и возвращающей значение этого же типа (a, b, c, d, k, m, n, x, y, z – переменные типа int):
a = func (3);
b = n + func (m);
c = func (z-y) + func (y+4);
cout << func (x);
d = func (func (k)); // "вложенный" вызов функции
Объявить функцию необходимо перед ее первым вызовом и сделать это можно одним из двух способов.
Во-первых, можно использовать предварительное объявление (прототип) функции, “анонсируя” последующее ее определение. Анонсированное прототипом определение функции может располагаться в любом последующем месте программы, например:
int func(int); // объявление (прототип) функции func
...
int main ()
{
int x, y;
...
x = func(y); // вызов (обращение к) функции func
...
}
int func(int a) // определение функции func
{
...
}
Понятно, что прототип и заголовок функции должны совпадать по типу возвращаемого значения и по последовательности типов параметров.
Еще один способ объявить функцию – расположить определение функции перед первым ее вызовом:
int func(int a)
{
...
}
int main ()
{
int x, y;
...
x = func(y);
...
}
Функция может не возвращать никакого значения. В этом случае её результат должен быть объявлен с типом void, а её вызов не может быть использован в выражении:
void func_2(int a)
{
cout << a * a;
}
int main ()
{
...
func_2 (10); // вызов функции func_2 типа void
...
}