Функции - Классы памяти

подпрограммы-процедуры и подпрограммы-функции, здесь вся программа строится только из функций,

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

необходимо декла-рировать.
Хорошим стилем программирования является выполнение следующих действий:
1) декларация

функции пользователя в форме описания прототипа, которая выполняется обычно в глобальной области, или до первого ее использования;
2) определение (реализация) функции, т.е. запись полного текста функции, которые могут располагаться в исходном файле в любом порядке.

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

– тип возвращаемого значения (если такое имеется), идентификатор (имя) функции, список типов параметров.
Общий вид декларации прототипа функций:

Тип возвращае- Имя
мого результата функции (Список);

не указывать, т.к. компилятор их не обрабатывает.
Описание прототипа дает

возможность компилятору проверить соответствие типов и количества параметров при вызове этой функции.
Пример прототипа функции Fun, которая имеет три параметра типа int, один параметр типа double и возвращает результат типа double:
double Fun ( int, int, int, double );

строка) и код, общий вид которого имеет (аналогично с прототипом)

следующий вид:
Тип возвращаемо- Имя
го результата функции (Список параметров)
{ – Начало функции
Код функции
return Выражение;
} – Конец функции
Декларация (описание) функции в проекте простой структуры может быть выполнена до ее вызова только Определением.

точку ее вызова при помощи оператора

return Выражение; (return - возврат).
Выражение преобразуется к указанному в заголовке функции Типу и передается в точку вызова.
Тип возвращаемого функцией значения может быть любым базовым типом, или созданным ранее типом Пользователя.

выходе из функции типа void используется оператор return;
В конце

кода функции типа void оператор return; можно не ставить.
Если тип функции не указан, то по умолчанию устанавливается тип int.
Список параметров в заголовке функции состоит из перечня не только типов, но и идентификаторов объектов, которые требуется передать в функцию при ее вызове.

типы и порядок следования параметров должны совпадать.
Тип возвращаемого результата

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

не быть ни одного, например в функции типа void (это

определяется потребностями алгоритма). В последнем случае возврат в вызывающую программу происходит после выполнения последнего оператора функции.
Пример реализации функции поиска наимень-шего из двух int значений:
int Min (int x, int y)
{
return (x < y) ? x : y;
}
Ее прототип: int Min (int, int);

Min (int x, int y)
{
if (x < y) return

x ;
else return y;
}
Или:
int Min (int x, int y)
{
int res;
if (x < y) res = x ;
else res = y;
return res;
}

возможен только через ее вызов.
Для вызова функции нужно указать

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

перед вызовом функции вычисляются.
Аргументы должны совпадать со списком параметров

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

рекомендуется, т.к. нужно стремиться к тому, чтобы функции в программе

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

результатов
В языке Си аргументы при вызове функции обычно передаются с

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

только одно значение, указанного в заголовке типа, или воспользоваться передачей

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

с использованием их идентификаторов, могут быть только входными;

– параметры, переданные

по адресу, т.е. с использованием указателей являются как входными так и выходными (возвращаемыми в точку вызова).

возвращаемый результат будет утерян.
Например стандартная функция getch();
1) если мы

ее используем так
getch();
то она выполняет только функцию задержки выполнения программы до нажатия любой клавиши;
2) если мы используем возвращаемый результат, то она выполнит не только ожидание нажатия клавиши, но и вернет код (символ) нажатой клавиши для дальнейшей обработки, т.е. например
if ( getch( ) == ‘N’ ) break;

( int, int ); – Прототип функции
Основная функция с обращением к

функции Sum:
void main ( )
{
int a = 2, b = 3, s;
s = Sum (a, b); - Сохранив значение
cout << “ Sum = " << s << endl;
cout << " Sum = " << Sum (2*a, 3*b) << endl;
- Вызов функции без сохранения ее результата
}

{
return x + y;
}
Иначе функцию Sum можно записать:
int

Sum ( int x, int y )
{
int s;
s = x + y;
return s;
}

Fun ( int, int, int*); – Прототип функции
Основная функция с обращением

к функции Fun:
void main (void)
{
int a = 2, b = 3, summa, razn;
summa = Fun (a, b, &razn);
cout << " A + B = " << summa
<< " A – B = " << razn << endl;
}

int *r )
{
*r = x – y;
return x +

y;
}
Третий параметр передается по адресу, поэтому он является и выходным значением, т.е. его измененное значение будет известно и в точке вызова этой функции.

можно задать новое имя с помощью операции typedef:

typedef

Тип Новое имя ;

Введенный таким образом новый тип исполь-зуется аналогично стандартным типам, например, введя пользовательские типы:
typedef unsigned int UINT; – UINT новое имя;
typedef double Real;

две переменные
типа unsigned int

Real x, y; - две

переменные типа double


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

на начало выделенной для нее памяти и не может быть

использована в левой части операции присваивания.
Но имеется возможность декларировать указатели на функции, т.е. указатели-переменные.
Рассмотрим методику работы с указателями на функции.

объявить:
Тип ( *Имя_Указателя ) ( Список );
- декларируется Указатель, который

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

и один int параметр;
int * fun2 ( int );

- прототип функции, результат которой – указатель типа int , и int параметр.
Декларация Указателя, который можно установить на функцию fun1
int ( *p_fun1 ) ( int );
А Указатель, который можно установить на функцию fun2
int * ( *p_fun2 ) ( int );

который можно устанавливать на функции, возвращающие double результат и имеющие

два параметра: int и double.
2. Чтобы установить Указатель на конкретную функцию, достаточно ему присвоить имя этой функции:
Имя_Указателя = Имя_Функции;
Например, для некоторой функции с прототипом:
double f1 ( int, double );
установим указатель p_f на функцию f1 , т.е.
p_f = f1;

– по ее имени;
p_f (21, 1.5); – по

имени указателя (по адресу);
(* p_f) (21, 1.5); – по указателю (по значению).
Основное назначение указателей на функции – это обеспечение возможности передачи конкретных функций в качестве формальных параметров в другие функции.

который определяет время и область действия объекта. Он может принимать

значения: auto, register (динамическая память), extern, static (статическая память).
Область действия объекта по умолчанию зависит от места их объявления и может быть локальной (внутренней) или глобальной (внешней).
Имеется три основных участка программы, где объявляются переменные:
– внутри функции (блока);
– в заголовке функции (описание параметров);
– вне функции.

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

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

другая функция не имеет прямого доступа к ним. Такие объекты

существуют временно на этапе активности функции.
Каждая локальная переменная существует только в блоке кода, в котором она объявлена, и уничтожается при выходе из него. Эти переменные располагаются в стековой области памяти и называются автоматическими.
Локальные объекты по умолчанию имеют атрибут auto.
Если хотят показать, что переменные не надо искать вне функции, то используют явное описание класса, например:
void main(void) {
auto int max, i, n;
...
}

Атрибут register рекомендует размещать объекты в регистрах общего назначения (процес-сора),

а не в оперативной памяти. При нехватке регистров компилятор может использовать другие способы размещения или просто проигнорировать данную рекомендацию.
Регистровая память позволяет увеличить быстродействие программы, но к размещаемым в ней объектам в языке Си не применима операция получения адреса «&».

могут иметь различные области действия.
В зависимости от места описания

статические переменные могут быть глобальными и локальными.
Время их жизни – постоянное.
Глобальные объекты всегда являются статическими.
В языке Си атрибут static имеет разный смысл для локальных и глобальных объектов.
При описании глобального объекта атрибут static определяет область применения (действия) этого объекта только в пределах остатка текущего файла.
Значения локальных статических объектов сохраняются до повторного вызова функции.

атрибут extern (внешняя).
Напомним, что время жизни и зона действия

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

регистровые переменные име-ют неопределенные начальные значения (мусор).

Параметры функции являются локальными

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

a = 3;
cout

a = 2.5;
cout << "2) a =" < {
char a = 'A';
cout << "3) a =" < }
cout << "New 2) a =" < }
cout << "New 1) a =" << ++a<

int i = 0; i < n; i++)

for ( int j = 0; j < m; j++)
. . .
Дальнейшее использование переменных i, j приведет к ошибке!
3. Объявление переменных в операторе switch:
switch (a) {
case 2: { - Необходимо
double m = 5; создать
. . . БЛОК
} break;
case 0: . . . break;
. . .
}
В связи с рассмотренными примерами, объявление всех переменных рекомендуется писать в начале функций.