Функции без возвращаемого значения (процедуры)

Приведем пример вызова функции, которая будет печатать строку «Вызвали функцию» на экран.

/* Используем свою функцию */
#include < stdio.h>
void function1(void); // Объявление функции
void main(void) // Точка входа в программу
{
function1(); // Вызов функции
}
/* Описание функции */
void function1(void) // Заголовок функции
{ // Начало тела функции
printf(" Вызвали функциюn" );
} // Конец тела функции

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

Мы объявили функцию function1(), затем её вызвали. В теле нашей функции function1() мы вызываем функцию printf(). Если внимательно рассмотреть текст программы, то можно увидеть строку #include, которая говорит компилятору, чтобы тот включил в текст программы файл с объявлениями функций стандартного ввода/вывода (standart input/output). Функция printf() объявлена именно там!

Директива препроцессора (preprocessor directive) просто вставляет текстовый файл stdio.h в текст программы. Причем вставляет туда, где стоит эта директива. Если убрать или закоментировать строку #include, то программа работать не будет, потому что функция printf() не будет объявлена. Компилятор выдаст ошибку - Function 'printf' should have a prototype (Функция 'printf' должна иметь прототип).

Необходимо обратить внимание ещё на то, что тип возвращаемого значения у функции void (пусто). Это значит, что функция не будет возвращать никакого значения.

Функции, возвращающие значение

Рассмотрим пример, в котором описаны две функции, для одной из которых указан тип возвращаемого значения - int.

#include < stdio.h> // Подключаем файл заголовков

// функций (их объявлений)

int x; // Объявляем переменную x (глобальная переменная)

void main(void)
{
void function1(void); // Объявляем функцию
int function2(); // function2() будет

// возвращать значение типа int

x = 10; // Присваиваем переменной x значение

printf(" До вызова функции function2() x равно %dn", x);

function1(); // Вызываем функцию function1()
x = function2(); // Вызываем функцию function2()

printf(" После вызова функции function2() x равно %dn", x);
}

/* Описание функций */
void function1(void)
{
printf(" Сделан вызов первой функцииn" );
}
int function2(void)
{
int y; // Объявляем локальную переменную
y = x + 10;

return y; // Возвращаем значение y
}

Теперь давайте посмотрим текст программы. После строки #include объявляем глобальную переменную x. Так как x - глобальная переменная, то она будет видна всем функция программы т.е. этой переменной могут пользоваться все функции.

В теле main() объявляем две функции, одна из которых может возвращать значение типа int. Далее присваиваем переменной x значение 10, так как x это глобальная переменная, то эта переменная будет видна функции main() т.е. функция main() может использовать эту переменную. После этого присвоения мы выводим значение x на экран.
На экране монитора появится следующая строка - «До вызова функции function2() x равно 10».

Далее мы вызываем функцию function1(). Эта функция просто выводит строку «Сделан вызов первой функцииn» на экран и так как в строке стоит n, то будет осуществлен переход на новую строку.

В следующей строке x = function2(); переменная x принимает значение которое вернет функция function2(). Посмотрите на описание функции function2(). В теле этой функции объявляем переменную y, а дальше переменной y мы присваиваем значение переменной x + 10. Так как x - глобальная переменная (она видна для функции function2), все будет работать.

Далее идет строка return y; с помощью оператора return мы возвращаем значение переменной y. Запомните, что если функция возвращает значение, то в теле этой функции обязательно должен присутствовать оператор return (он может быть и не один). Ну так вот с помощью оператора return мы возвращаем значение локальной переменной y в вызывающую функцию main().

Теперь посмотрим тело функции main() Следующей строкой после x = function2(); является строка printf(«После вызова функции function2() x равно %dn», x); которая выводи значение измененной переменной x;
На экране появится строка - «После вызова функции function2() x равно 20».

Функции с параметрами.

Функции языка С могут иметь параметры. Эти параметры передаются в функцию и там обрабатываются. Ещё раз рассмотрим основную форму описания функции:

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

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

function(int x, char a, float z)

Пример неправильного списка параметров:

function(int x, a, float z)

Рассмотрим все это на примере. Пусть будет функция, у которой присутствует один параметр x. Функция будет возвращать квадрат значения x.

int square(int x)
{
x = x * x; // Символ - операция умножения
return x;
}

Теперь рассмотри пример функции, которая будет выводить значение переменной z типа float на экран.

void myout(float z) // Переменная z является формальным

// параметром.
{
printf(" Z=%f", z); // %f - означает, что

// выводится число с плавающей точкой
}

Формальные и фактические параметры

Формальные параметры - это параметры которые объявляются в заголовке функции при описании.

Фактические параметры - это параметры которые подставляются при вызове функции.

void myfunc(int x); // Объявление функции
void main(void)
{
int a;
a=5;
myfunc(a); // a- фактический параметр
}
// Описание функции
void myfunc(int x) // x - формальный параметр
{
x = x + 10;
printf(" Вывод x = %d", x);
}

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

Перегрузка функций

При определении функций в программах обычно необходимо указать тип возвращаемого функцией значения, а также количество параметров и тип каждого из них. В прошлом (в первых версиях «чистого» С), если существовала функция с именем add_values, которая работала с двумя целыми значениями, а необходимо ещё было использовать подобную функцию для сложения трех целых значений, следовало создать функцию с другим именем. Аналогично если нужно было использовать подобную функцию для сложения значений типа float, то была бы необходима еще одна функция с еще одним именем.

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

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

#include < iostream.h>

int add_values(int a, int b)

{
return(a + b);
)

int add_values(int a, int b, int c)

(
return(a + b + c);
)

void main(void)

{
cout < < " 200 + 801 = " < < add_values(200, 801) < < endl;
cout < < " 100 + 201 + 700 = " < < add_values(100, 201, 700) < < endl;
}

Программа определяет две функции с именами add_values Первая функция складывает два значения типа int, в то время как вторая складывает три значения. Нет необходимости что-либо предпринимать специально для того, чтобы предупредить компилятор о перегрузке.

Одним из наиболее общих случаев использования перегрузки является применение функции для получения определенного результата, исходя из различных параметров. Например, предположим, что в программе есть функция с именем day_of_week, которая возвращает текущий день недели (0 для воскресенья, 1 для понедельника, ..., 6 для субботы). Программа могла бы перегрузить эту функцию таким образом, чтобы она верно возвращала день недели, если ей передан юлианский день в качестве параметра, или если ей переданы день, месяц и год:

int day_of_week(int julian_day)

{
// Операторы
}

int day_of_week(int month, int day, int year)

{
// Операторы
}

⇐ Предыдущая 1 234 5 6 7 8 9 10 Следующая ⇒