Чем процедура отличается от функции в программировании. Типы и функции Зачем нужны функции в программировании
Страница 51 из 85
1.5.1. Определение и вызов функций
Мощность языка программирования С во многом определяется легкостью и гибкостью в определении и использовании функций в программах на языке программирования С. В отличие от других языков программирования высокого уровня в языке программирования С нет деления на процедуры, подпрограммы и функции, здесь вся программа строится только из функций.
Функция - это совокупность объявлений и операторов, обычно предназначенная для решения определенной задачи. Каждая функция должна иметь имя, которое используется для ее объявления, определения и вызова. В любой программе на С должна быть функция с именем main (главная функция), именно с этой функции, в каком бы месте программы она не находилась, начинается выполнение программы.
При вызове функции ей при помощи аргументов (формальных параметров) могут быть переданы некоторые значения (фактические параметры), используемые во время выполнения функции. Функция может возвращать некоторое (одно!) значение. Это возвращаемое значение и есть результат выполнения функции, который при выполнении программы подставляется в точку вызова функции, где бы этот вызов ни встретился. Допускается также использовать функции не имеющие аргументов и функции не возвращающие никаких значений. Действие таких функций может состоять, например, в изменении значений некоторых переменных, выводе на печать некоторых текстов и т.п..
С использованием функций в языке программирования С связаны три понятия - определение функции (описание действий, выполняемых функцией), объявление функции (задание формы обращения к функции) и вызов функции.
Определение функции задает тип возвращаемого значения, имя функции, типы и число формальных параметров, а также объявления переменных и операторы, называемые телом функции, и определяющие действие функции. В определении функции также может быть задан класс памяти.
Int rus (unsigned char r)
{ if (r>="А" && c<=" ") return 1; else return 0; }
В данном примере определена функция с именем 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;
}
При вызове такой функции в качестве фактических параметров должны быть использованы не значения переменных, а их адреса
Если требуется вызвать функцию до ее определения в рассматриваемом файле, или определение функции находится в другом исходном файле, то вызов функции следует предварять объявлением этой функции. Объявление (прототип) функции имеет следующий формат:
[спецификатор-класса-памяти] [спецификатор-типа] имя-функции ([список-формальных-параметров]) [,список-имен-функций];
В отличие от определения функции, в прототипе за заголовком сразу же следует точка с запятой, а тело функции отсутствует. Если несколько разных функций возвращают значения одинакового типа и имеют одинаковые списки формальных параметров, то эти функции можно объявить в одном прототипе, указав имя одной из функций в качестве имени-функции, а все другие поместить в список-имен-функций, причем каждая функция должна сопровождаться списком формальных параметров. Правила использования остальных элементов формата такие же, как при определении функции. Имена формальных параметров при объявлении функции можно не указывать, а если они указаны, то их область действия распространяется только до конца объявления.
Прототип - это явное объявление функции, которое предшествует определению функции. Тип возвращаемого значения при объявлении функции должен соответствовать типу возвращаемого значения в определении функции.
Если прототип функции не задан, а встретился вызов функции, то строится неявный прототип из анализа формы вызова функции. Тип возвращаемого значения создаваемого прототипа int, а список типов и числа параметров функции формируется на основании типов и числа фактических параметров используемых при данном вызове.
Таким образом, прототип функции необходимо задавать в следующих случаях:
1. Функция возвращает значение типа, отличного от int.
2. Требуется проинициализировать некоторый указатель на функцию до того, как эта функция будет определена.
Наличие в прототипе полного списка типов аргументов параметров позволяет выполнить проверку соответствия типов фактических параметров при вызове функции типам формальных параметров, и, если необходимо, выполнить соответствующие преобразования.
В прототипе можно указать, что число параметров функции переменно, или что функция не имеет параметров.
Если прототип задан с классом памяти static, то и определение функции должно иметь класс памяти static. Если спецификатор класса памяти не указан, то подразумевается класс памяти extern.
Вызов функции имеет следующий формат:
адресное-выражение ([список-выражений])
Поскольку синтаксически имя функции является адресом начала тела функции, в качестве обращения к функции может быть использовано адресное-выражение (в том числе и имя функции или разадресация указателя на функцию), имеющее значение адреса функции.
Список-выражений представляет собой список фактических параметров, передаваемых в функцию. Этот список может быть и пустым, но наличие круглых скобок обязательно.
Фактический параметр может быть величиной любого основного типа, структурой, объединением, перечислением или указателем на объект любого типа. Массив и функция не могут быть использованы в качестве фактических параметров, но можно использовать указатели на эти объекты.
Выполнение вызова функции происходит следующим образом:
1. Вычисляются выражения в списке выражений и подвергаются обычным арифметическим преобразованиям. Затем, если известен прототип функции, тип полученного фактического аргумента сравнивается с типом соответствующего формального параметра. Если они не совпадают, то либо производится преобразование типов, либо формируется сообщение об ошибке. Число выражений в списке выражений должно совпадать с числом формальных параметров, если только функция не имеет переменного числа параметров. В последнем случае проверке подлежат только обязательные параметры. Если в прототипе функции указано, что ей не требуются параметры, а при вызове они указаны, формируется сообщение об ошибке.
2. Происходит присваивание значений фактических параметров соответствующим формальным параметрам.
3. Управление передается на первый оператор функции.
4. Выполнение оператора return в теле функции возвращает управление и возможно, значение в вызывающую функцию. При отсутствии оператора return управление возвращается после выполнения последнего оператора тела функции, а возвращаемое значение не определено.
Адресное выражение, стоящее перед скобками определяет адрес вызываемой функции. Это значит что функция может быть вызвана через указатель на функцию.
int (*fun)(int x, int *y);
Здесь объявлена переменная fun как указатель на функцию с двумя параметрами: типа int и указателем на int. Сама функция должна возвращать значение типа int. Круглые скобки, содержащие имя указателя fun и признак указателя *, обязательны, иначе запись
int *fun (intx,int *y);
будет интерпретироваться как объявление функции fun возвращающей указатель на int.
Вызов функции возможен только после инициализации значения указателя fun и имеет вид:
В этом выражении для получения адреса функции, на которую ссылается указатель fun используется операция разадресации * .
Указатель на функцию может быть передан в качестве параметра функции. При этом разадресация происходит во время вызова функции, на которую ссылается указатель на функцию. Присвоить значение указателю на функцию можно в операторе присваивания, употребив имя функции без списка параметров.
Double (*fun1)(int x, int y);
double fun2(int k, int l);
fun1=fun2; /* инициализация указателя на функцию */
(*fun1)(2,7); /* обращение к функции */
В рассмотренном примере указатель на функцию fun1 описан как указатель на функцию с двумя параметрами, возвращающую значение типа double, и также описана функция fun2. В противном случае, т.е. когда указателю на функцию присваивается функция описанная иначе чем указатель, произойдет ошибка.
Рассмотрим пример использования указателя на функцию в качестве параметра функции вычисляющей производную от функции cos(x).
Double proiz(double x, double dx, double (*f)(double x));
double fun(double z);
int main()
{
double x; /* точка вычисления производной */
double dx; /* приращение */
double z; /* значение производной */
scanf("%f,%f",&x,&dx); /* ввод значений x и dx */
z=proiz(x,dx,fun); /* вызов функции */
printf("%f",z); /* печать значения производной */
return 0;
}
double proiz(double x,double dx, double (*f)(double z))
{ /* функция вычисляющая производную */
double xk,xk1,pr;
xk=fun(x);
xk1=fun(x+dx);
pr=(xk1/xk-1e0)*xk/dx;
return pr;
}
double fun(double z)
{ /* функция от которой вычисляется производная */
return (cos(z));
}
Для вычисления производной от какой-либо другой функции можно изменить тело функции fun или использовать при вызове функции proiz имя другой функции. В частности, для вычисления производной от функции cos(x) можно вызвать функцию proiz в форме
z=proiz(x,dx,cos);
а для вычисления производной от функции sin(x) в форме
z=proiz(x,dx,sin);
Любая функция в программе на языке программирования С может быть вызвана рекурсивно, т.е. она может вызывать саму себя. Компилятор допускает любое число рекурсивных вызовов. При каждом вызове для формальных параметров и переменных с классом памяти auto и register выделяется новая область памяти, так что их значения из предыдущих вызовов не теряются, но в каждый момент времени доступны только значения текущего вызова.
Переменные, объявленные с классом памяти static, не требуют выделения новой области памяти при каждом рекурсивном вызове функции и их значения доступны в течение всего времени выполнения программы.
Классический пример рекурсии - это математическое определение факториала n! :
N! = 1 при n=0;
n*(n-1)! при n>1 .
Функция, вычисляющая факториал, будет иметь следующий вид:
Long fakt(int n)
{
return ((n==1) ? 1: n*fakt(n-1));
}
Хотя компилятор языка программирования С не ограничивает число рекурсивных вызовов функций, это число ограничивается ресурсом памяти компьютера и при слишком большом числе рекурсивных вызовов может произойти переполнение стека.
Пришло время, чтобы узнать о функциях. Вы уже имеете представление об использовании функции main , — это еще один пример функции. В общем, функции — это отдельные независимые блоки кода, которые выполняют ряд предопределенных команд. В языке программирования Си вы можете использовать как встроенные функции различных библиотек так и функции, которые вы создали сами, то есть свои собственные функции.
Функции, которые мы будем создавать сами, обычно требуют объявления прототипа. Прототип дает основную информацию о структуре функции: он сообщает компилятору, какое значение функция возвращает, как функция будет вызываться, а также то, какие аргументы функции могут быть переданы. Когда я говорю, что функция возвращает значение, я имею в виду, что функция в конце работы вернет некоторое значение, которое можно поместить в переменную. Например, переменная может быть инициализирована значением, которое вернет функция:
#include
Ошибкой является то, что многие начинающие программисты думают, что значение в переменной randomNumber каждый раз будет случайно меняться, это не так. Она будет инициализирована случайным значением единожды, при вызове функции , но не при каждом запуске программы.
Рассмотрим общий формат для прототипа функций:
ReturnedDataType functionName (dataType par1, ..., dataType parN);
где, returnedDataType — тип данных, возвращаемого функцией, значения;
functionName — имя функции
dataType — тип данных параметра функции, это тот же самый тип данных, что и при объявлении переменной
par1 ... parN — параметры функции.
У функции может быть более одного параметра или вообще ни одного, в таком случае круглые скобки пустые. Функции, которые не возвращают значения имеют тип данных возвращаемого значения — void . Давайте посмотрим на прототип функции:
Int mult (int x, int y);
Этот прототип сообщает компилятору, что функция принимает два аргумента, в качестве целых чисел, и что по завершению работы функция вернет целое значение. Обязательно в конце прототипа необходимо добавлять точку с запятой. Без этого символа, компилятор, скорее всего, подумает, что вы пытаетесь написать собственно определения функции.
Когда программист фактически определяет функцию, он начнет с прототипа, но точку с запятой уже ставить не надо. Сразу после прототипа идет блок с фигурными скобочками и с кодом, который функция будет выполнять. Например, как вы обычно пишите код внутри функции main . Любой из аргументов, переданных функции можно использовать, как если бы они были объявлены как обычные переменные. И, наконец, определение функции заканчивается закрывающейся фигурной скобкой, без точек с запятой.
Давайте рассмотрим пример объявления и использования функции в языке программирования Си:
#include
Эта программа начинается с включения единственного заголовочного файла, в строке 1. Следующей строкой является прототип функции умножения. Обратите внимание, что в конце объявления прототипа есть точка с запятой! Функция main возвращает целое число, в строке 16. Чтобы соответствовать стандарту функция main всегда должна возвращать некоторое значение. У вас не должно возникнуть проблем с пониманием ввода и вывода значений в функциях, если вы внимательно изучили предыдущие уроки.
Обратите внимание на то как на самом деле функция multiplication() принимает значение. Что же происходит на самом деле? А на самом деле это работает так: функция multiplication принимает два целых значения, умножает их и возвращает произведение. Результат работы этой программы будет точно таким же, как если бы мы сделали так:
Printf("Результат умножения %d\n", num1 * num2);
Функция multiplication() на самом деле определяется ниже функции main . А так как прототип этой функции объявлен выше главной функции, то при вызове функции multiplication() внутри main() компилятор не выдаст ошибку. Пока прототип присутствует, функция может использоваться даже если нет её фактического определения. Тем не менее, вызов функции не может быть осуществлен ранее, чем будет определена эта функция.
Определение прототипов функций необходимы только если фактическое определение самой функции будет располагаться после main-функции. Если же функцию определить до главной функции, то прототип не нужен.
Ключевое слово return , используется для того, чтобы заставить функцию возвращать значение. Обратите внимание на то, что вполне успешно можно объявлять функции, которые не возвращают никаких значений. Если функция возвращает значение типа void , значит фактически функция не имеет возвращаемого значения. Другими словами, для функции, которая возвращает значение типа void , утверждение return; является законным, но обычно оно избыточно. (Хотя оно может быть использовано для экстренного выхода из функции.)
Наиболее важным является понимание, для чего же нам нужна функция? Функции имеют множество применений. Например, в программе есть блок кода, который необходимо выполнять в разных местах программы около сорока раз. То есть один раз объявили функцию и уже вызываете её там где это необходимо,при этом код не дублируется, что позволит сэкономить много места, что в свою очередь сделает программу более читаемой. Кроме того, наличие только одной копии кода делает его легче для внесения изменений.
Еще одна причина для использования функций, это разделение всего кода на отдельные логические части. Таким образом сложные задачи разбиваются на более простые, это очень помогает при сопровождении кода, структуру такой программы будет намного легче понять.
P.S.: если вам нужен хороший сервер, то вы можете воспользоваться арендой серверов в Москве . Также вы можете воспользоваться другими услугами, предоставленными на сайте it-express.ru: развертывание отказоустойчивых серверов, системы хранения данных и др.
Не зря эту статью, я назвал «Функции, как неотъемлемая часть программирования», ведь без них, по моему мнению, ни один язык не имеет право на существование. Что же это такое? Функция - это главная составляющая хорошо написанной программы. Она облегчает не только чтение кода, но и в корне меняет представление о структурном программировании. При помощи функций, Вы можете многократно использовать отдельные части программы, передавая им какие-либо параметры. Ни одну серьезную программу невозможно представить без этого чуда элемента программирования.
Расскажу вкратце, как это работает. Функция, - это блок инструкций, который Ваша программа может вызвать. При обращении к заголовку этого блока (названии функции), он выполняется и совершает какие-то действия, задаваемые программистом. После этого, этот блок возвращает полученное значение и передает в главную программу. Поясню на практике.
Грубо говоря, все выглядит так. Коротко поясню. Мы создаем какую-нибудь переменную и присваиваем ей результат выполнения функции myfunc, которая в свою очередь вычисляет значение возведения в квадрат какого-нибудь числа. Функции не исполняются сразу во время запуска программы, а исполняются только тогда, когда к ним обращаются. Может немного запутанно, но все именно так.
Как вызвать функцию?
Для того, чтобы вызвать функцию, необходимо ее создать. Хотя существуют, так же, встроенные функции. Например, это: cos, sin, md5, count, abs и так далее. Для их вызова необходимо лишь присвоить переменной искомое значение.
Аргумент функции - это значение, передаваемое Вами ей при вызове. Аргументы функции помещаются в скобках. При создании функции Вы указываете условные имена аргументов. Потом этими именами можно пользоваться в теле функции, как локальными переменными. Вернемся к функциям, которые создает сам пользователь. Это делается очень легко. Сначала создается тело функции:
Function hello() { echo "Hello, world!"; }
Затем ее вызываем. Причем если она не имеет параметров, то мы просто ставим круглые скобки. Чтобы вызвать эту функцию, воспользуемся лишь строчкой: hello(); . Любая функция может так же возвращать значение с помощью зарезервированного слова return . Этот оператор прекращает выполнение функции и посылает возвращаемое значение в вызвавшую программу. function sum($first, $second) {$r=$first + $second; return $r;} echo sum(2,5); результат выполнения программы будет равен 7. Локальные и глобальные переменные
Как и в любом другом языке программирования, существую переменные, доступные только внутри функции и переменные, доступные в коде самой программы. Такие переменные называются локальные и глобальные соответственно. Внутри функции Вы не можете просто так обратиться к переменной, которая была создана вне этой функции. Если Вы попытаетесь это сделать, то создадите новую переменную с таким же именем, но локальную для данной функции.
$per="Дима"; function primer() // Выполняет: вывод локальной переменной { echo "Меня зовут ".$per; } echo primer();
В данном случае на экране появится фраза «Меня зовут». Это означает, что внутри функции primer создалась переменная $per и ей, по-умолчанию, было присвоено нулевое значение. Для того, чтобы избежать таких косяков, нужно воспользоваться оператором global . В соответствии с этим исправим вышеизложенный код:
$per="Дима"; function primer() // Выполняет: вывод глобальной переменной { global $per; echo "Меня зовут ".$per; } echo primer();
Теперь должно быть все в порядке - проблема решена. Только не стоит забывать, что если функция изменит значение внешней переменной, то такое изменение скажется на всей программе, поэтому пользоваться этим оператором нужно осторожно!
Функции двух и более аргументов
Некоторые из аргументов, передаваемые функции, можно сделать необязательными, уменьшив требовательность функции. В следующем примере это наглядно показано:
…
function font($text, $size=5)
// Выполняет: вывод размера шрифта
{ echo "".$text."";
}
font("Привет
",1);
font("Привет
",2);
font("Привет
",3);
font("Привет
",4);
font("Привет
",5);
font("Привет
",6);
font("Привет
");
По умолчанию, размер кегля равен 5. Если мы опускаем второй параметр у функции, то он будет равен этому значению.
Заключение
Прежде чем попрощаться, хочу обратить Ваше внимание на одном совете. Он заключается в том, чтобы вынести все написанные Вами функции в один файл (например, function.php). А затем, в файле, где необходимо обратиться к функции, достаточно лишь подключить function.php и все будет готово к использованию. Это намного облегчит понимание логики в Вашей программе. Для подключения, используйте:
include_once("function.php");
require_once("function.php");
Если Вы поняли суть рассматриваемого вопроса в этой статье, то я уверен, что Вы без труда сможете пользоваться функциями в своих программах. Еще раз повторюсь, это необходимо для того, чтобы сделать их более пригодными для внесения изменений и повторного использования.
Принципы программирования на языке Си основаны на понятии функции. Обычно программы на этом языке состоят из большого числа небольших функций. Программа может находиться в одном или нескольких файлах, которые можно раздельно транслировать и вместе загружать, добавляя предварительно оттранслированные функции из библиотек.
Что такое функция? Функция – самостоятельная поименованная единица программы, реализующая конкретную задачу . Функции языка Си играют ту же роль, что и функции, процедуры и подпрограммы в других языках программирования. Они повышают уровень модульности программы, облегчают ее чтение, внесение изменений и коррекцию ошибок и, самое главное облегчают разработку алгоритмов решения задачи, позволяя разбивать её н a подалгоритмы (функции). (англ. subprogram, subroutine, function)
Все функции языка Си подразделяются на две группы: встроенные и определяемые пользователем . Встроенные (стандартные) функции могут вызываться по имени без предварительного определения. Встроенные функции хранятся в виде объектного кода в специальных файлах (библиотеках ) с расширением . lib . Для работы с библиотеками имеются специальные средства, в том числе программа lib . exe . Функции пользователя организовываются самим программистом в соответствии с синтаксисом языка. Предварительное определение функций пользователя обязательно. Программист может собрать разработанные им функции в библиотеки и затем использовать их наравне со встроенными функциями.
Что требуется знать о функциях? Нужно знать, как их можно определять, как к ним обращаться и как устанавливать связи между функцией и программой, ее вызывающей.
Все функции в программе, написанной на языке Си, равноправны: каждая из них может вызывать любую другую функцию и каждая, в свою очередь, может быть вызвана любой другой функцией.
Программа, написанная на языке Си, всегда начинает выполняться с функции, называемой main(), поэтому мы имеем возможность выбирать имена для всех используемых нами функций, кроме той, с которой начинается выполнение программы. Однако на этом специфика функции main() заканчивается, даже она может быть вызвана другими функциями (случай рекурсивности).
Любая функция должна быть, прежде всего, определена . Определение функции состоит из заголовка и тела функции и является, по сути дела, программной реализацией этой функции. Для того чтобы функцию можно было использовать, ее нужно описать в том файле трансляции, где она будет использоваться (определение функции может находиться и в другом файле трансляции).
Различают два типа описаний: объявления и прототипы . В языке Си в объявлении описываются только имя функции и тип возвращаемого значения (тип функции). В языке С++ объявляются прототипы функций. В С/С++ в прототипе описываются имя функции, тип возвращаемого значения и типы передаваемых ей формальных параметров. Количество и тип параметров функции называются сигнатурой функции.
Прототипы библиотечных функций содержатся, как правило, в заголовочных (header ) файлах и включаются в программой директивой препроцессора include .
Функции, которые находятся в одном и том же файле трансляции, назовем вместе транслируемыми . Функции, которые находятся в разных файлах трансляции, назовем раздельно транслируемыми .
Цель работы: 1) изучить правила описания функций; 2) приобрести навыки использования функций при написании программ на языкеC++.
Теоретические сведения
Основным модулем программ в языке С++ является функция.
Функция - логически завершенный, определенным образом оформленный фрагмент программы, имеющий имя. Функции позволяют разделить большие вычислительные задачи на более мелкие.
Каждая программа на языке С++ обязательно содержит функцию с именем main (главная), которая является телом программы. Для всех остальных функций, если они присутствуют в программе, следует объявлять прототипы - схематические записи, которые сообщают компилятору имя и форму каждой функции в программе.
Синтаксис для прототипа функций с параметрами:
тип_возвращаемого_значения имя_функции (список_параметров_с_указанием_типов);
Функции в С++ бывают стандартные (библиотечные) и программируемые пользователем.
Стандартные функции
Описания стандартных функций находятся в файлах, включаемых в программу с помощью директивы #include. Такие файлы называют заголовочными; они имеют расширение h.
Обращение к имени функции в основной программе называется вызовом функции.
Вызов функций приводит к выполнению некоторых действий или вычислению некоторой величины, используемой затем в программе.
y = sin (x); //функция вычисления синуса
Определение функции
В общем виде функции определяются следующим образом:
тип_возвращаемого_значения имя_функции (тип имя_параметра,...,тип имя_параметра)
тело_функции
Программируемые функции
Функции, которые программист создает сам, упрощают процесс написания программ, поскольку они:
помогают избежать повторного программирования, так как одну и ту же функцию можно применять в различных программах;
повышают уровень модульности программы, следовательно, облегчают ее чтение, внесение изменений и коррекцию ошибок.
Пример 9 .1. Создадим функцию, которая печатает 65 символов "*" в ряд. Чтобы эта функция выполнялась в некотором контексте, она включена в программу печати фирменного бланка. Программа состоит из функций: main() и stars().
// Фирменный бланк
#include
const int Limit=65;
void stars(void); // прототип функции stars()
cout<<"Moscow Institute of
Electronic Engineering"< // Определение функции stars() for (count=1; count<=Limit; count++) Мы рассмотрели пример простейшей
функции, не имеющей аргументов и не
возвращающей никаких значений. Рассмотрим на примере использование
параметров функции. Пример
9.
2.
Напишем
функцию space(),
в качестве аргумента
которой будет число пробелов, которое
должна напечатать эта функция. #define address " Zelenograd" #define name " Moscow Institute Electronic Engineering " #define department " Informatics and Programming" const int LIMIT=65; #include void space(int number); cout< spaces=(LIMIT - strlen(name))/2; // Вычислить,
сколько // нужно пробелов cout< space((LIMIT - strlen(department))/2); //
аргумент – выражение cout< //Определение функции stars() for
(count=1; count<=LIMIT; count++) //Определение функции space() void space(int number) for (count=1; count <=number; count++) Переменная
number называется формальным аргументом.
Эта переменная приобретает значения
фактического аргумента при вызове
функции. Другими словами, формальный
аргумент
- переменная в определении
вызываемой подпрограммы, афактический
аргумент
- конкретное значение,
присвоенное этой переменной вызывающей
программой. Если для связи с некоторой функцией
требуется более одного аргумента, то
наряду с именем функции можно задать
список аргументов, разделенных запятыми: void printnum (int i, int j) { cout<<"Координаты
точек”<< i << j < Входная величина функции может
обрабатываться благодаря наличию
аргумента
; выходная величина
возвращается при помощи ключевого словаreturn.Параметры функций
