Приведем пример вызова функции, которая будет печатать строку «Вызвали функцию» на экран.
/* Используем свою функцию */
#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)
{
// Операторы
}