Функции. Определение (описание) функции. Прототип (декларирование) функции. Параметры функции. Передача аргументов в функцию.

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

1. Функции, которые не возвращают значений
2. Функции, возвращающие значение

Определение и вызов функций

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

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

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

С использованием функций в языке СИ связаны три понятия - определение функции (описание действий, выполняемых функцией), объявление функции (задание формы обращения к функции) и вызов функции.

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

Пример:

int rus (unsigned char r) { if (r>='А' && c

В данном примере определена функция с именем rus, имеющая один параметр с

именем r и типом unsigned char. Функция возвращает целое значение, равное 1,

если параметр функции является буквой русского алфавита, или 0 в противном

случае.

В языке СИ нет требования, чтобы определение функции обязательно

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

определением функции main, перед ним, или находится в другом файле.

Однако для того, чтобы компилятор мог осуществить проверку соответствия

типов передаваемых фактических параметров типам формальных параметров до вызова

функции нужно поместить объявление (прототип) функции.

Объявление функции имеет такой же вид, что и определение функции, с той лишь

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

могут быть опущены. Для функции, определенной в последнем примере, прототип

может иметь вид

int rus (unsigned char r); или rus (unsigned char);

В программах на языке СИ широко используются, так называемые, библиотечные

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

Прототипы библиотечных функций находятся в специальных заголовочных файлах,

поставляемых вместе с библиотеками в составе систем программирования, и

включаются в программу с помощью директивы #include.

Если объявление функции не задано, то по умолчанию строится прототип функции

на основе анализа первой ссылки на функцию, будь то вызов функции или

определение. Однако такой прототип не всегда согласуется с последующим

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

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

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

несоответствие аргументов устанавливаемое при выполнении программы.

Объявление параметров функции при ее определении может быть выполнено в так

называемом "старом стиле", при котором в скобках после имени функции следуют

только имена параметров, а после скобок объявления типов параметров. Например,

функция rus из предыдущего примера может быть определена следующим образом:

int rus (r) unsigned char r; { ... /* тело функции */ ... }

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

форму:

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

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

который может быть static или extern. Подробно классы памяти будут рассмотрены

в следующем разделе.

Спецификатор-типа функции задает тип возвращаемого значения и может задавать

любой тип. Если спецификатор-типа не задан, то предполагается, что функция

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

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

указатель на любой тип, в том числе и на массив и на функцию. Тип возвращаемого

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

объявлении этой функции.

Функция возвращает значение если ее выполнение заканчивается оператором

return, содержащим некоторое выражение. Указанное выражение вычисляется,

преобразуется, если необходимо, к типу возвращаемого значения и возвращается в

точку вызова функции в качестве результата. Если оператор return не содержит

выражения или выполнение функции завершается после выполнения последнего ее

оператора (без выполнения оператора return), то возвращаемое значение не

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

использован тип void, указывающий на отсутствие возвращаемого значения. Если

функция определена как функция, возвращающая некоторое значение, а в операторе

return при выходе из нее отсутствует выражение, то поведение вызывающей функции

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

Список-формальных-параметров - это последовательность объявлений формальных

параметров, разделенная запятыми. Формальные параметры - это переменные,

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

копирования в них значений соответствующих фактических параметров.

Список-формальных-параметров может заканчиваться запятой (,) или запятой с

многоточием (,...), это означает, что число аргументов функции переменно.

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

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

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

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

Если функция не использует параметров, то наличие круглых скобок

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

Порядок и типы формальных параметров должны быть одинаковыми в определении

функции и во всех ее объявлениях. Типы фактических параметров при вызове

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

Тип формального параметра может быть любым основным типом, структурой,

объединением, перечислением, указателем или массивом. Если тип формального

параметра не указан, то этому параметру присваивается тип int.

Для формального параметра можно задавать класс памяти register, при этом для

величин типа int спецификатор типа можно опустить.

Идентификаторы формальных параметров используются в теле функции в качестве

ссылок на переданные значения. Эти идентификаторы не могут быть переопределены

в блоке, образующем тело функции, но могут быть переопределены во внутреннем

блоке внутри тела функции.

При передаче параметров в функцию, если необходимо, выполняются обычные

арифметические преобразования для каждого формального параметра и каждого

фактического параметра независимо. После преобразования формальный параметр не

может быть короче чем int, т.е. объявление формального параметра с типом char

равносильно его объявлению с типом int. А параметры, представляющие собой

действительные числа, имеют тип double.

Преобразованный тип каждого формального параметра определяет, как

интерпретируются аргументы, помещаемые при вызове функции в стек.

Несоответствие типов фактических аргументов и формальных параметров может быть

причиной неверной интерпретации.

Тело функции - это составной оператор, содержащий операторы, определяющие

действие функции.

Все переменные, объявленные в теле функции без указания класса памяти,

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

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

Управление передается первому оператору тела функции и начинается выполнение

функции, которое продолжается до тех пор, пока не встретится оператор return

или последний оператор тела функции. Управление при этом возвращается в точку,

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

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

и поэтому старые значения локальных переменных теряются.

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

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

производится инициализация значениями фактических параметров. При выходе из

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

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

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

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

операцию разадресации можно изменить значение этой переменной.

Пример:

/* Неправильное использование параметров */ void change (int x, int y) { int k=x; x=y; y=k; }

В данной функции значения переменных x и y, являющихся формальными

параметрами, меняются местами, но поскольку эти переменные существуют только

внутри функции change, значения фактических параметров, используемых при вызове

функции, останутся неизменными. Для того чтобы менялись местами значения

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

примере.

Пример:

/* Правильное использование параметров */ void change (int *x, int *y) { int k=*x; *x=*y; *y=k; }

При вызове такой функции в качестве фактических параметров должны быть

использованы не значения переменных, а их адреса

change (&a,&b);

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

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

следует предварять объявлением этой функции. Объявление (прототип) функции

имеет следующий формат:

[спецификатор-класса-памяти] [спецификатор-типа] имя-функции

([список-формальных-параметров]) [,список-имен-функций];

В отличие от определения функции, в прототипе за заголовком сразу же следует

точка с запятой, а тело функции отсутствует. Если несколько разных функций

возвращают значения одинакового типа и имеют одинаковые списки формальных

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

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

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

формальных параметров. Правила использования остальных элементов формата такие

же, как при определении функции. Имена формальных параметров при объявлении

функции можно не указывать, а если они указаны, то их область действия

распространяется только до конца объявления.