Лекция 09
.pdfКафедра автоматизации технологических процессов Тверского государственного технического университета
Разработчик: доцент В. Г. Васильев
ЛЕКЦИЯ № 9 «Подпрограммы (функции) в C/ С++»
по курсу «Структуры и алгоритмы обработки данных»
для специальности «Управление в технических системах»)
СОДЕРЖАНИЕ
9.1.Основные определения.
9.2.Передача параметров в подпрограммы.
9.3 Область видимости переменных в функциях С/С++, расширение области видимости переменных.
9.4. Перегрузка функций в C++.
9.1. Основные определения
Подпрограмма – именованная, логически законченная группа операторов языка, которую можно вызвать для выполнения любое количество раз из различных мест программы. В языке С/С++ подпрограммы реализованы в виде функций. Функция принимает параметры и возвращает единственное скалярное значение. Как известно, программа на С/С++ состоит из одной или нескольких функций. Функция должна быть описана перед своим использованием.
Описание функции состоит из заголовка и тела функции. Заголовок_функции
{
тело_функции
}
Заголовок функции имеет вид
type имя_функции ([список параметров])
type – тип возвращаемого функцией значения; Тип функции показывает, какое значение возвращает функция: целое, вещественное, строковое и так далее. Если тип функции не указан, то подразумевается, что функция возвращает целое значение типа int.
список параметров – список параметров (аргументов) содержит перечень типов и имен величин, разделенных запятыми, и заключенных в скобки. Если функция не имеет параметров, то скобки все равно необходимы, хотя в них ничего не указывается, то есть в скобках в этом случае будет пустое место.
Например:
fun1(int a, int b, float d);
В случае, если вызываемые функции определены до функции main, структура программы будет такой.
директивы компилятора
...
Тип_результата f1(Список_переменных)
{
Операторы
}
Тип_результата f2(Список_переменных)
{
Операторы
}
...
Тип_результата fn(Список_переменных)
{
Операторы
}
int main(Список_переменных)
{
Операторы основной функции, среди которых могут операторы вызова функций f1, f2, ..., fn
}
В случае, если вызываемые функции определены после функции main или даже в другом файле, необходимо до первого вызова функции сообщить
программе тип возвращаемого функцией значения, а также количество и типы ее аргументов. Подобное сообщение называется прототипом функции.
директивы компилятора
...
Тип_результата f1(Список_переменных); Тип_результата f2(Список_переменных);
...
Тип_результата fn(Список_переменных); int main(Список_переменных)
{
Операторы основной функции, среди которых могут операторы вызова функций f1, f2, ..., fn
}
Тип_результата f1(Список_переменных)
{
Операторы
}
Тип_результата f2(Список_переменных)
{
Операторы
}
...
Тип_результата fn(Список_переменных)
{
Операторы
}
Прототипы функции. Прототип функции имеет следующий вид
тип<имя функции>(список параметров)
Использование прототипа называют еще объявлением функции или просто ее declaration. Прототип может полностью совпадать с заголовком функции, хотя при объявлении функции компилятору необходимо знать только имя функции, количество аргументов и их типы и тип возвращаемого функцией значения. Поэтому имена аргументов как имена формальных параметров не имеют никакого значения и игнорируются компилятором.
Поэтому прототип функции может иметь один из следующих видов:
int fun1(int x, int y, char* c); или int fun1(int, int, char*);
Если возврата функции не требуется, то тип возвращаемого значения функцией –void.
Возврат значений с помощью оператора return.
Для того, чтобы функция вернула какое-либо значение, в ней должен быть оператор возврата
return значение;
Если тип возвращаемого значения функцией –void, то оператор возврата просто – return и его можно даже опустить в теле функции.
Return вызывает немедленный выход из функции и возврат в основную подпрограмму. С помощью оператора return из функции возвращается единственное значение. Это может быть число, адрес, структура.
Пример. Подпрограмма для вычисления определенного интеграла методом Ромберга.
Параметры
1.float (*f)(float ) – указатель на функцию, возвращающую тип float и имеющую один формальный параметр (float ).
2.float a –нижний предел интегрирования;
3.float b– верхний интегрирования.
float Romberg (float (*f)(float ),float a, float b)
{
float d,s,h ,rombint; int m,n,i,j,k;
float t[15];
k =12;
d = b - a;
t[0] =(f(a) + f(b)) / (float)2.0; n = 1;
for ( i = 1 ; i < k+1 ; i ++)
{
s = ( float ) 0.0; n = 2 * n;
h = d / n;
for ( j = 1 ; j <= n ; j = j + 2) s = s + f( a + j * h );
t [i+1-1]= ( 2* s/n + t [i-1]) / (float)2.0;
m = 1;
for ( j = i; j >= 1 ; j --)
{
m = 4 * m;
t[ j -1] = t [j ] + (t[j ] - t [j - 1])/ (m - 1);
}
}
rombint = t[0] * d;
return (rombint);
}
Пример вызова функции Romberg
// прототипы
float Romberg (float (*f)(float ),float a,float b); float func_1 ( float t);
void __fastcall TForm1::Integral11Click(TObject *Sender)
{
float integ; String S;
integ = Romberg (func_1, 0.0, 10.0); S.sprintf("Интеграл =%f",integ); Label1->Caption = S;
return;
}
// Функция для вычисления интеграла функции y =x3. float func_1( float x)
{
float y;
return y = x*x*x;
}
9.2. Передача параметров в подпрограммы
Параметры, указанные в заголовке функции, называются формальными. Параметры, передаваемые в функцию, называются фактическими.
При обращении к функции фактические параметры передают свое значение формальным и больше не изменяются. Типы, количество и порядок следования формальных и фактических параметров должны совпадать.
9.3 Область видимости переменных в функциях С/С++, расширение области видимости переменных
По месту объявления переменные в языке Си можно разделить на два класса:
1.Локальные – переменные, которые объявляются внутри функции
идоступны только в ней.
Например: int main()
{
float s; s=4.5;
}
int f1()
{
int s; s=6;
}
int f2()
{
long int s; s=25;
}
В функции main определена вещественная переменная s (типа float), ей присвоено значение 4.5, в функции f1 есть другая переменная s (типа int), ей присвоено значение 6, а в функции f2 есть еще одна переменная s (типа long int), ей присвоено значение 25.
2.Глобальные – переменные, которые описаны до всех функций, они доступны из любой функции.
Например:
#include <stdio.h> float s;
int main()
{
s=4.5;
}
int f1()
{
s=6;
}
int f2()
{
s=25;
}
Определена глобальная переменная s (типа float), в функции main ей присваивается значение 4.5, в функции f1 – присваивается значение 6, а в функции f2 – присваивается значение 25.
Рассмотрим особенности использования локальных и глобальных переменных в программах на С++:
1.Область видимости и использования локальной переменной ограничена функцией, где она определена.
2.Глобальные переменные объявляются вне любых функций и их областью видимости является весь файл.
3.Однако тоже имя может использоваться при определении глобальной и локальной переменной. В этом случае в функции, где определена локальная переменная действует локальное описание, вне этой функции «работает» глобальное описание.
Из функции, где действует локальное описание переменной, можно обратиться к глобальной переменной с таким же именем, используя оператор расширения области видимости ::переменная.
9.4. Перегрузка функций в C++
Язык С++ позволяет связать с одним и тем же именем функции различные определения, т. е. возможно существование нескольких функций с одним и тем же именем. У этих функций может быть разное количество параметров или разные типы параметров. Создание двух или более функций с одним и тем же именем называется перегрузкой имени функции. Перегруженные функции следует создавать, когда одно и то же действие следует выполнить над разными типами входных данных, а иногда одна и та же функция над разными типами входных данных выполняется с помощью разных алгоритмов.
Перегрузка функции (function overloading) – это определение двух или более функций с одинаковым именем, но разными наборами параметров.
Функции, имеющие общее имя, называются перегруженными (over-loaded).
Допустим, что в программе требуется часто перемножать две переменные, но разных типов (int, float и double). В Си для этого понадобилось бы написать три функции:
// объявления функций для программы на Си int multiplyInt(int num1, int num2);
float multiplyFloat(float num1, float num2);
double multiplyDouble (double num1, double num2);
Иметь три разные функции не совсем удобно.Проще иметь одну функцию multiply() решающую данную задачу. Вот как выглядят объявления для перегруженных функций в С++:
// объявления в С++
int multiply(int num1, int num2);
float multiply(float num1, float num2); double multiply(double num1, double num2);
Таким образом, в программе на С++, также как и на языке С, по-прежнему требуется написать отдельные функции для каждого из этих объявлений, но теперь все функции должны иметь одно и то же имя. Компилятор выберет нужную функцию, основываясь на аргументах, которые вы ей передаете.
Например:
float х = 1,5; float у = 10.5;
float result = multiply(х, у);
Компилятор видит, что функции передаются два числа типа float и вызывает соответствующую версию multiply(). Аналогичным образом, если передаются два целых числа, будет вызвана целочисленная версия multiply().
Работа перегруженных функций основана на различии списков параметров. Вы можете варьировать тип и/или количество аргументов, принимаемых функцией, но нельзя создавать перегруженные функции, различающиеся только типом возвращаемого значения. Например, следующий фрагмент не рассматривается, как перегрузка функций:
int DoSomething(); void DoSomething();
Если вы попытаетесь откомпилировать программу, содержащую подобные строки, то получите сообщение об ошибке «Type mismatch in redeclaration of
'DoSomething()» (Несоответствие типа в повторном объявлении 'DoSomething()').
Эти две функции должны различаться не только возвращаемым значением, чтобы быть перегруженными.
Таким образом, функции С++ предоставляют программисту дополнительные возможности по сравнению с функциями Си. С++ позволяет иметь несколько функций с одинаковым именем, но различными наборами параметров.