Лекция 14. Функция – это часть программы, которая выполняет какое-либо законченное действие

Введение в функции.

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

В общем случае программа на языке С++ - это совокупность функций.

Различают объявление и определение функции. Объявление (прототип)позволяет компилятору узнать имя функции, тип значения, возвращаемого функцией, и тип параметров, которые она может иметь. Компилятору нужно знать эту информацию до первого вызова функции. Единственная функция, которая не требует прототипа, это функция main(), поскольку она встроена в язык С++.

Прототип имеет следующий синтаксис:

<тип функции><имя функции>(<список формальных параметров>);

Здесь < типфункции > - это любой тип, за исключением массива. Если функция не возвращает никакого значения, необходимо указать void.

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

<тип><имя параметра>

или

<тип><имя параметра> = <умалчиваемое значение>

Если функция не имеет параметров, то список либо отсутствует, но скобки остаются, либо указывается слово void.

В конце прототипа ставится “;”

Примеры прототипов функций.

void print (int value);

float min (float x, float y);

int sqr(int x);

float max (float, float y); // опустили имя

void write (void);

Определение функции, кроме объявления, содержит тело функции. Синтаксис определения функции:

<тип функции><имя функции>(<список формальных параметров>){ <тело функции>}

Здесь < тело функции > - это либо составной оператор, либо блок. Если функция не выполняет никаких действий, то телом функции является { }.

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

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

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

#include “<имя файла>”

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

return <выражение>;

или

return;

Здесь < выражение > - это возвращаемой функцией значение. Тип возвращаемого значения определяется типом функции. Если функция имеет тип void, то < выражение > в операторе returnопускается. Можно опустить и сам оператор.

В теле функции может быть несколько операторов return. Операторreturnможно использовать в главной функции main().Если тип возвращаемого ею результата отличен от void, то при благоприятном завершении программы возвращается значение 0, в противном случае – не 0.

Примеры определений функций.

1) float min (float x, float y)

{ if (x < y) return x; // два оператора return

else return y;

}

2) int sqr (int x)

{ return x*x; // один оператор return

}

3) void print (int value)

{ cout << “\n” << value; // нет оператора return

}

Вызов функции выполняется с помощью конструкции

<имя функции>(<список фактических параметров>);

Здесь <имя функции> - это имя функции из ее заголовка;

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

Рассмотрим механизм активизации функции на примере.

Создадим программу, включающую объявление и определение функции box(),вычисляющей объем параллелепипеда, и главную функцию main(),в теле которой организуем многократный вызов функции box().

#include <iostream.h>

void box(int length, int width, int height);

void main()

{ box (7,20, 4);

box (50,3,2);

box (8,6,9);

}

void box((int length, int width, int height)

{

cout << “Объем параллелепипеда = “ << length*width*height << “\n”;

}

При вызове функции:

1. формальным параметром присваиваются значения аргументов;

2. выполняются операторы тела функции;

3. управление передается конструкции, записанной в теле основной функции за конструкцией вызова функции.

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

При вызове функции нужно помнить следующее правила:

1. количество и тип фактических параметров (аргументов) должны строго соответствовать количеству и типу формальных параметров (параметров);

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

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

#include <iostream.h>

int box(int length, int width, int height)

{

return length*width*height;

}

void main()

{

int answer;

answer = box(10,11,3);

cout << “объем параллелепипеда = ” << answer;

}

Здесь функция box() определена до её использования в функции main(). Таким образом, её определение служит и ее прототипом, поэтому нет необходимости в отдельном включении прототипа в программу.

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

Области видимости функций

Правила действия областей видимости любого языка программирования позволяют управлять доступом к объекту из различных частей программы. В С++ определены две основные области видимости: локальная и глобальная.

Локальная область видимости создается блоком. Переменная, объявленная внутри блока, называется локальной. Локальные переменные не доступны вне блока. Локальные переменные существуют только во время выполнения программного блока, в котором они объявлены. Это значит, что локальная переменная создается при входе в блок и разрушается при выходе из него.

Тело функции является программным блоком, который начинается с “{“ изавершается “}”. Каждая функция определяет собственную область видимости.

Пример.

#include <iostream.h>

void f(); // прототип функции

void main()

{ int value = 10; // локальная по отношению к main()

cout << “ Значение value в функции main():” << value << “|n”;

f();

cout << “ Значение value в функции main():” << value << “|n”;

}

void f() // определение функции

{ int value = 88; // локальная в функции f()

cout << “ Значение value в функции f():” << value << “|n”;

}

Результат:

Значение value в функции main(): 10

Значение value в функции f(): 88

Значение value в функции main(): 10

Каждая переменная value известна только своему блоку.

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

Например:

void main()

{ cout << “Введите первое число”;

int a;

cin >> a;

cout << “Введите второе число”;

int b;

cin >> b;

cin << “a*b=” << a*b << ‘\n’;

}

Если имя переменной, объявленной во внутреннем блоке, совпадет с именем переменной, объявленной во внешнем блоке, то внутренняя переменная переопределяет внешнюю в пределах видимости внутреннего блока.

Пример.

int main()

{ int i, j;

i = 10;

j = 100;

if (j>0) {

int i; i = j/2;

cout << “Внутренняя переменная i:” << i << ‘\n’;

}

cout << “Внешняя переменная i:” << i << ‘\n’;

}

Результат:

Внутренняя переменная i:50

Внешняя переменная i:10

Формальные параметры функции существуют в пределах области видимости функции, они локальны по отношению к функции.

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

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

Глобальные переменные объявляют вне всех функций, например, до функции main(). Формально они должны быть определены до их первого использования.

Пример.

#include <iostream.h>

void f1();

void f2();

int count; // глобальная переменная

void main ()

{

int i; // локальная переменная

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

{ count = i*2;

f1();

}

} // конец функции main(()

void f1()

{ cout << “count: “ << count; // доступ к глобальной переменной

cout << ‘\n’;

f2();

}

void f2()

{

int count; // локальная переменная

for (count=0; count<3; count++)

cout <<’.’;

}

Результат:

count: 0

... count: 2

... count: 4

...

В этом примере функция main() и функция f1() используют глобальную переменную count. Но в функции f2() объявляется локальная переменная count, которая внутри функции перекрывает глобальную и не оказывает на неё никакого влияния.

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

- они занимают память в течение всего времени выполнения программы и не только тогда, когда действительно необходимы;

- использование большого количества глобальных переменных может привести к ошибкам в программе;

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

Вопросы

1. Конструкция

int f(char c,int k,float b);

является:

1. заголовком функции;

2. определением функции;

3. прототипом;

4. сигнатурой.

2. Задан текст программы

#include<iostream.h>

void f(int x=0, int y=100);

void main()

{f(10);}

void f(int x, int y)

{cout<<”x=”<<x<<”,y=”<<y<<”\n”;}

Укажите правильный результат:

1. x=0, y=100

2. x=10, y=0

3. x=10, y=100

4. x=0, y=10

5. x=10, y=10

3. Даны три фрагмента программ

1) int F(int a)

{…}

int c,d;

void main()

{…

c=F(d);

…

}

2) int F(int x)

{…}

int a;

void main()

{…}

3) int F (int x)

{int a;

…

}

В каком фрагменте переменная a является локальной?

1. 1;

2. 2;

3. 3.