Моля, спрете AdBlock на този сайт.

И така, защо имаме нужда от персонализирани функции? Дефинираните от потребителя функции са необходими, за да улеснят програмистите да пишат програми.

Не забравяйте, че говорихме за парадигми на програмиране, по-точно за структурирано програмиране. Основната идея беше, че всяка програма може да бъде написана само с три основни конструкции: следване, условие и цикъл. Сега ще добавим още една към тези структури - „подпрограми“ - и ще получим нова парадигма процедурно програмиране".

Единствената разлика е, че ще напишем отделни части от нашата основна програма (по-специално, повтарящи се) под формата на отделни функции (подпрограми, процедури) и ще ги извикаме, ако е необходимо. По същество програмата сега ще описва взаимодействието на различни функции.

Така че в този урок ще обсъдим подробно как функциите се изграждат вътрешно. Ще научим също как да създаваме свои собствени персонализирани функции.

Как работят функциите

Нека си припомним информацията от първия урок. Всички функции, включително написаните от потребителя, са подредени по подобен начин. Те имат две основни части: заглавката на функцията и тялото на функцията.

Списък 1.

Int main(void)( // заглавка на функция // тялото на функцията е написано във фигурни скоби)

Всичко е ясно с тялото на функцията: той описва алгоритъма на функцията. Да погледнем заглавието. Състои се от три задължителни части:

• тип връщане;
• име на функция;
• аргументи на функцията.

Първо се записва връщащият тип, например int , както в основната функция. Ако функцията не трябва да върне никаква стойност на програмата, тогава пишете в тази точка ключова думапразен Изглежда, че тъй като функцията не връща нищо, тогава няма нужда да пишете нищо. Преди това, между другото, това беше направено на езика C, но след това го добавиха за еднаквост. В наши дни съвременните компилатори ще издават предупреждения/грешки, ако не посочите тип на връщане.
В някои езици за програмиране функциите, които не връщат никаква стойност, се наричат ​​процедури (например Pascal). Освен това има различни синтаксиси за създаване на функции и процедури. В езика C няма такава дискриминация.

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

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

Списък 2.

// функция с име srand, която приема цяло число, не връща нищо void srand(int) // функция, наречена sqrt, която взема реално числоот тип float, връща реално число от тип float float sqrt(float) //функция с име rand, която не приема аргументи, връща цяло число int rand(void) //функция с име pow, която приема два аргумента от тип double, връща реално число от тип double double pow(double, double)

Как да създадете своя собствена функция

За да създадете своя собствена функция, трябва да я опишете напълно. Тук работи общо правило: преди да го използвате, декларирайте и опишете как трябва да работи. За да направите това, нека се върнем към диаграмата на структурата на програмата C, която имахме в първия урок. Нека отбележим върху него местата, където могат да бъдат описани функциите.

Фиг.1 Изясняване на структурата на програмата. Декларация на функции.

Както можете да видите, има две места, където това може да се направи.

Нека да разгледаме пример, който илюстрира създаването на персонализирана функция за изчисляване на максимум две числа.

Списък 3.

#включи // деклариране на персонализирана функция с наречен макс _num // вход: два целочислени параметъра с имена a и b // изход: максимум два аргумента int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; ) / /главна програма int main(void) ( int x = 0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf(" max (%d,%d) = %d\n",x,y,m); върне 0; )

Нека опиша подробно как ще работи тази програма. Тялото на основната функция се изпълнява. Създават се целочислените променливи x, y и m. Променливите x и y се четат от клавиатурата. Да кажем, че сме въвели 3 5, тогава x = 3, y = 5. Всичко това трябва да ви е ясно. Сега следващият ред

Списък 4.

M = max_num(x,y);

Променливата m трябва да бъде присвоена на това, което е вдясно от знака =. Там имаме името на функцията, която създадохме сами. Компютърът търси декларацията и описанието на тази функция. Намира се над. Според тази реклама тази функциятрябва да приема две цели числа. В нашия случай това са стойностите, записани в променливите x и y. Тези. номера 3 и 5. Моля, обърнете внимание, че не самите променливи x и y се предават на функцията, а само стойностите (две числа), които се съхраняват в тях. Това, което всъщност се предава на функция, когато тя се извиква в програма, се нарича действителните параметри на функцията.

Сега функцията max_num започва да се изпълнява. Първата стъпка е да създадете отделна временна променлива за всеки параметър, описан в заглавката на функцията. В нашия случай се създават две целочислени променливи, наречени a и b. На тези променливи се присвояват стойностите на действителните параметри. Самите параметри, описани в заглавката на функцията, се наричат ​​формални параметри. Така на формалните параметри a и b се присвояват стойностите съответно на действителните параметри 3 и 5. Сега a = 3, b = 5. По-нататък във функцията можем да работим с тези променливи, сякаш са обикновени променливи.

Създава се целочислена променлива с име max и й се присвоява стойност b. След това се проверява условието a > b. Ако е вярно, тогава стойността в променливата max трябва да бъде заменена с .

Следва операторът return, който връща на извикващата програма (главна функция) стойността, записана в променливата max, т.е. 5. След което променливите a, b и max се изтриват от паметта. И се връщаме на линията

Списък 5.

M = max_num(x,y);

Функцията max_num върна стойност 5, което означава, че сега има 5, изписано вдясно от знака =. Тази стойност се записва в променливата m. След това редът се показва на екрана и програмата приключва.

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

Междувременно ще ви кажа защо е необходим долният блок от описания на функциите. Представете си, че сте написали 20 малки функции във вашата програма. И всички те са описани преди основната функция. Не е много удобно да стигнете до основната програма толкова дълго. За да се реши този проблем, функциите могат да бъдат описани в долен блок.

Но няма да е възможно просто да прехвърлите целия функционален код там, защото тогава правилото ще бъде нарушено: преди да използвате нещо, трябва да го декларирате. За да избегнете този проблем, трябва да използвате прототип на функция.

Прототипът на функцията напълно повтаря заглавката на функцията, последвана от ; . След като посочихме прототипа в горния блок, в долния вече можем да опишем напълно функцията. За горния пример може да изглежда така:

Списък 6.

#включи int max_num(int, int); int main(void) ( int x =0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf("max(%d ,%d) = %d\n",x,y,m); return 0; ) int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; )

Много е просто. Моля, имайте предвид, че прототипът на функцията не трябва да указва имената на формалните параметри; достатъчно е просто да посочите техните типове. В горния пример направих точно това.

Последна актуализация: 22.09.2017

Определение на функцията

Функцията определя действията, които програмата изпълнява. Функциите ви позволяват да изберете набор от инструкции и да му дадете име. И след това го извикайте многократно, като използвате присвоеното име в различни части на програмата. По същество функцията е наименуван блок от код.

Формалната дефиниция на функция е както следва:

Въведете име на функция (параметри) ( инструкции )

Първият ред представлява заглавката на функцията. Първо се посочва типът на връщане на функцията. Ако функцията не върне никаква стойност, тогава се използва тип void.

Следва името на функцията, което представлява произволен идентификатор. Същите правила важат за именуване на функции и за именуване на променливи.

След името на функцията параметрите са изброени в скоби. Функцията може да няма параметри, в който случай се посочват празни скоби.

След главата на функцията във фигурни скоби следва тялото на функцията, което съдържа инструкциите, които трябва да бъдат изпълнени.

За да върне резултата, функцията използва израза return. Ако дадена функция има тип на връщане от какъвто и да е тип, различен от void, тогава тя трябва да върне някаква стойност, използвайки израза return.

Например дефиницията на основната функция, която трябва да бъде във всяка програма на C++ и от която започва нейното изпълнение:

Int main() ( return 0; )

Типът връщане на функция е int, така че функцията трябва да използва оператор return и да връща някаква стойност, която съответства на типа int. Върнатата стойност се поставя след оператора return.

Но ако функцията е от тип void, тогава не е необходимо да връща нищо. Например, можем да дефинираме следната функция:

Void hello() ( std::cout<< "hello\n"; }

Изпълнение на функция

За да се изпълни функция, тя трябва да бъде извикана. Функцията се извиква във формата:

име_на_функция(аргументи);

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

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

#включи void hello() ( std::cout<< "hello\n"; } int main() { hello(); hello(); return 0; }

Това дефинира функцията hello, която се извиква два пъти в основната функция. Това е предимството на функциите: можем да поставим някои общи действия в отделна функция и след това да ги извикваме многократно на различни места в програмата. В резултат на това програмата ще отпечата низа „здравей“ два пъти.

Декларация на функция

Когато използвате функции, струва си да имате предвид, че компилаторът трябва да знае за функцията, преди да я извика. Следователно извикването на функция трябва да се случи след като е дефинирана, както в горния случай. В някои езици това няма значение, но в C++ има голяма разлика. И ако например първо извикаме и след това дефинираме функция, ще получим грешка на етапа на компилация, както в следния случай:

#включи int main() ( hello(); hello(); return 0; ) void hello() ( std::cout<< "hello\n"; }

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

тип име_на_функция(параметри);

Това всъщност е заглавката на функцията. Тоест за функцията hello декларацията ще изглежда така:

Празно здравей();

Използваме декларация на функция:

#включи void hello(); int main() ( hello(); hello(); return 0; ) void hello() ( std::cout<< "hello\n"; }

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

За какво са предназначени функциите в C?

Функциите в C се използват за извършване на конкретни действия в рамките на обща програма. Програмистът сам решава кои действия да показва във функциите. Особено удобно е да използвате функции за повтарящи се действия.

Прост пример за функция в C

Пример за функция в C:

#включи #включи int main(void) ( puts("Функции в C"); return EXIT_SUCCESS; )

Това е много проста C програма. Той просто отпечатва реда "Функции в C". Програмата има една функция, наречена main. Нека разгледаме подробно тази функция. В заглавката на функцията, т.е. на линия

int е типът връщане на функцията;

main е името на функцията;

(void) е списък с аргументи на функцията. Думата void показва, че функцията няма аргументи;

return е оператор, който прекратява изпълнението на функция и връща резултата от функцията до точката, в която функцията е била извикана;

EXIT_SUCCESS е стойност, равна на нула. Той е дефиниран във файла stdlib.h;

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

{
puts("Функции в C");
връщане EXIT_SUCCESS;
}

наречено тяло на функцията.

И така, когато работим с функция, трябва да посочим името на функцията, за нас то е main, типа на стойността, върната от функцията, за нас е int, да дадем списък с аргументи в скоби след име на функцията, нямаме аргументи, затова пишем void, изпълняваме в тялото на функцията някои действия (заради които е създадена функцията) и връщаме резултата от функцията, използвайки израза return. Ето основите, които трябва да знаете за функциите в C.

Как да извикам друга функция от една функция в C?

Нека да разгледаме пример за извикване на функции в C:

/* Автор: @author Subbotin B.P..h> #include int main(void) (puts("Функции в C"); int d = 1; int e = 2; int f = sum(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS)

Пускаме го и получаваме:

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

заглавка на функцията за сумиране:

int сума (int a, int b)

тук int е връщаният тип на функцията;

sum е името на функцията;

(int a, int b) - в скоби след името на функцията има списък с нейните аргументи: първият аргумент е int a, вторият аргумент е int b. Имената на аргументите са формални, т.е. Когато извикваме функция, не се изисква да изпращаме стойностите на променливите с имена a и b като аргументи на тази функция. В основната функция извикваме функцията sum по следния начин: sum(d, e);. Но е важно аргументите, предадени на функцията, да съответстват на типа, деклариран във функцията.

В тялото на функцията сума, т.е. Вътре във фигурните скоби след заглавката на функцията създаваме локална променлива int c, присвояваме й стойността на сумата от a плюс b и я връщаме като резултат от функцията с израза return.

Сега нека видим как функцията сума се извиква от основната функция.

Ето основната функция:

Int main(void) ( puts("Functions in C"); int d = 1; int e = 2; int f = sum(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS)

Първо създаваме две int променливи

Int d = 1;

int e = 2;

Ще ги предадем на функцията сума като стойности на аргумент.

int f = сума (d, e);

int сума (int a, int b)

аргументите се наричат ​​a и b, защо тогава предаваме d и f? Тъй като формалните аргументи се записват в заглавката на функцията, т.е. Имената на аргументите НЕ са важни, но типовете им са важни. Функцията sum има и двата аргумента от тип int, което означава, че когато извиквате тази функция, трябва да подадете два аргумента от тип int с произволни имена.

Още една тънкост. Една функция трябва да бъде декларирана преди да бъде извикана за първи път. В нашия пример това се случи: първо се декларира функцията sum и след това я извикваме от основната функция. Ако функция е декларирана след мястото, където е извикана, тогава трябва да се използва прототип на функция.

Функционален прототип в C

Нека да разгледаме пример за функция в C:

/* Автор: @author Subbotin B.P..h> #include int сума (int a, int b);

int main(void) (puts("Функции в C"); int d = 1; int e = 2; int f = sum(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS; int sum(int a, int b) ( int c = 0; c = a + b; return c; )

В този пример функцията сума е дефинирана по-долу, където се извиква в основната функция. В този случай трябва да използвате прототипа на функцията за сумиране. Нашият прототип е деклариран над основната функция:

int сума (int a, int b);

Ще ги предадем на функцията сума като стойности на аргумент.

Прототипът е заглавка на функция, която завършва с точка и запетая. Прототипът е декларация на функция, която ще бъде дефинирана по-долу. Точно това направихме: декларирахме прототип на функция

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

Int sum(int a, int b) ( int c = 0; c = a + b; return c; )

Как декларацията на функция в C е различна от дефиницията на функция в C?

В този пример функцията сума е дефинирана по-долу, където се извиква в основната функция. В този случай трябва да използвате прототипа на функцията за сумиране. Нашият прототип е деклариран над основната функция:

Когато пишем прототип на функция, например така:

след това декларираме функция.

И когато имплементираме функция, т.е. Записваме не само заглавието, но и тялото на функцията, например:

Int sum(int a, int b) ( int c = 0; c = a + b; return c; )

след това дефинираме функция.

изявление за връщане

И когато имплементираме функция, т.е. Записваме не само заглавието, но и тялото на функцията, например:

Инструкцията return завършва функция в C и връща резултата от нейната операция до точката на повикване. Пример:

Тази функция може да бъде опростена:

Int sum(int a, int b) ( return a + b; )

тук операторът return ще върне стойността на сумата a + b.

В една функция може да има няколко оператора за връщане. Пример:< 0) { return 0;// Второй случай; } return a + b; }

Int sum(int a, int b) ( if(a > 2) ( return 0;// Първи случай; ) if(b

И само ако и двете предишни условия не са изпълнени, тогава изпълнението на програмата ще достигне последния оператор за връщане и ще бъде върната сумата a + b.

Предаване на аргументите на функцията по стойност

Аргументите могат да се предават на C функция по стойност. Пример:

/* Автор: @author Subbotin B.P..h> #include int sum(int a) ( return a += 5; ) int main(void) ( puts("Функции в C"); int d = 10; printf("sum = %d\n", sum(d)) ; printf("d = %d", d); return EXIT_SUCCESS;

В примера в основната функция създаваме променлива int d = 10. Предаваме тази променлива по стойност на функцията sum(d). Вътре в функцията сума стойността на променливата се увеличава с 5. Но в основната функция стойността на d няма да се промени, защото е предадена по стойност. Това означава, че е предадена стойността на променливата, а не самата променлива. Това се доказва от резултата от програмата:

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

Предаване на указатели на C функция

Ако подадете стойност като аргумент на функция променлив указателна тази променлива, тогава стойността на тази променлива може да се промени. Например, вземаме програмата от предишния раздел, като я променяме леко:

/* Автор: @author Subbotin B.P..h> #include int sum(int *a) ( return *a += 5; ) int main(void) (puts("Функции в C"); int d = 10; printf("sum = %d\n", sum(&d )); printf("d = %d", d); return EXIT_SUCCESS;

В тази версия на програмата преминах от предаване на аргумент по стойност към предаване на указател към променлива. Нека разгледаме по-подробно тази точка.

printf("сума = %d\n", сума(&d));

Това, което се предава на функцията сума, не е стойността на променливата d, равна на 10, а адресът на тази променлива, както следва:

Сега нека да разгледаме функцията сума:

Int sum(int *a) ( return *a += 5; )

Неговият аргумент е указател към int. Знаем, че указателят е променлива, чиято стойност е адресът на някакъв обект. Адресът на променливата d се изпраща на функцията sum:

Вътре в sum указателят int *a се дереферира. Това ни позволява да преминем от указателя към самата променлива, към която сочи указателят. И в нашия случай това е променливата d, т.е. изразяване

е еквивалентен на израза

Резултат: функцията сума променя стойността на променливата d:

Този път стойността на d се променя след връщане от сума, което не беше наблюдавано в предишния параграф, когато подадохме аргумента по стойност.

C/C++ в Eclipse

Направих всички примери за тази статия в Eclipse. Можете да видите как да работите с C/C++ в Eclipse. Ако работите в различна среда, примерите ще работят и там.

Време е да научите за функциите. Вече имате представа за използването на основната функция - това е друг пример за функция. Като цяло функциите са отделни, независими блокове код, които изпълняват серия от предварително дефинирани команди. В езика за програмиране C можете да използвате както вградени функции на различни библиотеки, така и функции, които сте създали сами, т.е. ваши собствени функции.

Функциите, които ще създадем сами, обикновено изискват декларация на прототип. Прототипът предоставя основна информация за структурата на функция: той казва на компилатора каква стойност връща функцията, как ще бъде извикана функцията и какви аргументи на функцията могат да бъдат предадени. Когато казвам, че една функция връща стойност, имам предвид, че в края на своята работа функцията ще върне някаква стойност, която може да бъде поставена в променлива. Например, една променлива може да бъде инициализирана със стойността, която функцията ще върне:

#включи // свързване на заглавката с функцията rand rand() int randomNumber = rand(); // стандартна функциягенериране на случайни числа

Грешката е, че много начинаещи програмисти смятат, че стойността в променливата randomNumber ще се променя произволно всеки път, това не е така. Тя ще бъде инициализирана с произволна стойност веднъж, когато функцията бъде извикана, но не всеки път, когато програмата се изпълнява.

Нека да разгледаме общия формат за прототип на функция:

ReturnedDataType functionName(dataType par1, ..., dataType parN);

където returnedDataType е типът данни, върнат от функцията;
functionName — име на функция
dataType - типът данни на параметъра на функцията, това е същият тип данни, както при декларирането на променливата
par1 ... parN — параметри на функцията.

Една функция може да има повече от един параметър или нито един, в който случай скобите са празни. Функциите, които не връщат стойност, имат тип данни за връщана стойност void. Нека да разгледаме прототипа на функцията:

Int mult(int x, int y);

Този прототип казва на компилатора, че функцията приема два аргумента като цели числа и че функцията ще върне целочислена стойност, когато завърши. Не забравяйте да добавите точка и запетая в края на прототипа. Без този символ компилаторът вероятно ще помисли, че се опитвате да напишете действителни дефиниции на функции.

Когато програмистът действително дефинира функция, той ще започне с прототип, но няма нужда да добавя точка и запетая. Веднага след прототипа има блок с фигурни скоби и кода, който функцията ще изпълни. Например, как обикновено пишете код вътре в основната функция. Всеки от аргументите, предадени на функцията, може да се използва, сякаш е деклариран като обикновена променлива. И накрая, дефиницията на функцията завършва със затваряща фигурна скоба, без точка и запетая.

Нека да разгледаме пример за деклариране и използване на функция в езика за програмиране C:

#включи int умножение (int num1, int num2); //прототип на функция int main() ( int num1; int num2; printf("Въведете две числа за умножение: "); scanf("%d", &num1); scanf("%d", &num2); printf(" Резултат от умножение %d\n", умножение(num1, num2)); // извикване на функция getchar(); return 0; ) int multiplication(int num1, int num2) // дефиниция на функция ( return num1 * num2; )

Тази програма започва с включване на един заглавен файл на ред 1. Следващият ред е прототип за функцията за умножение. Имайте предвид, че има точка и запетая в края на декларацията на прототипа! Основната функция връща цяло число на ред 16. За да отговаря на стандарта, основната функция винаги трябва да връща някаква стойност. Не трябва да имате проблем с разбирането на входа и изхода на стойности във функциите, ако сте проучили внимателно предишните уроци.

Забележете как функцията multiplication() всъщност приема стойност. Какво наистина се случва? Но в действителност работи по следния начин: функцията за умножение взема две цели числа, умножава ги и връща продукта. Резултатът от тази програма ще бъде абсолютно същият, както ако направихме това:

Printf("Резултат от умножение %d\n", num1 * num2);

Функцията multiplication() всъщност е дефинирана под основната функция. И тъй като прототипът на тази функция е деклариран над основната функция, компилаторът няма да изведе грешка при извикване на функцията multiplication() вътре в main(). Докато прототипът е налице, функцията може да се използва дори ако няма действителна дефиниция. Обаче не може да се направи извикване на функция, преди функцията да е дефинирана.

Дефинирането на прототипи на функции е необходимо само ако действителната дефиниция на самата функция ще бъде разположена след основната функция. Ако функцията е дефинирана преди основната функция, тогава не е необходим прототип.

Ключовата дума return се използва, за да принуди функция да върне стойност. Обърнете внимание, че е напълно възможно да декларирате функции, които не връщат никакви стойности. Ако функция върне стойност от тип void, тогава функцията всъщност няма върната стойност. С други думи, за функция, която връща стойност от тип void, изразът return; е законно, но обикновено е излишно. (Въпреки че може да се използва за излизане от функция при спешен случай.)

Най-важното е да разберем защо имаме нужда от функция? Функциите имат много приложения. Например, една програма има блок от код, който трябва да бъде изпълнен на различни места в програмата около четиридесет пъти. Тоест декларирате функция веднъж и я извиквате където трябва, без да дублирате кода, което ще спести много място, което от своя страна ще направи програмата по-четима. Освен това наличието само на едно копие на кода улеснява извършването на промени.

Друга причина да използвате функции е да разделите целия код на отделни логически части. По този начин сложните задачи се разделят на по-прости, това е много полезно при поддържане на кода, структурата на такава програма ще бъде много по-лесна за разбиране.

P.S.: ако имате нужда добър сървър, тогава можете да използвате сървър под наем в Москва. Можете също да използвате други услуги, предоставени на сайта it-express.ru: внедряване на устойчиви на грешки сървъри, системи за съхранение на данни и др.

Досега сме писали програми в единен, функционално неделим код. Програмният алгоритъм се съдържаше в основната функция и нямаше други функции в програмата. Написахме малки програми, така че нямаше нужда да декларираме нашите функции. За писане на големи програми опитът показва, че е по-добре да се използват функции. Програмата ще се състои от отделни кодови фрагменти; отделен кодов фрагмент е функция. Отделно, защото работата на отделна функция не зависи от работата на никоя друга. Тоест алгоритъмът във всяка функция е функционално достатъчен и независим от другите програмни алгоритми. След като напишете функция, тя може лесно да бъде прехвърлена в други програми. Функция (в програмирането) е част от код или алгоритъм, реализиран на някакъв език за програмиране с цел извършване на определена последователност от операции. И така, функциите ви позволяват да направите програма модулна, тоест да разделите програмата на няколко малки подпрограми (функции), които заедно изпълняват задачата. Друг голям плюс на функциите е, че могат да се използват повторно. Тази функция ви позволява да използвате повторно веднъж написан код, което от своя страна значително намалява количеството програмен код!

В допълнение към факта, че C++ осигурява декларирането на своите функции, можете също да използвате функции, дефинирани в стандартните заглавни файлове на езика за програмиране C++. За да използвате функцията, дефинирана в заглавния файл, трябва да я включите. Например, за да използвате функция, която повишава определено число на степен, трябва да включите заглавен файл и стартирайте функцията pow() в тялото на програмата. Нека разработим програма, в която ще изпълняваме функцията pow().

// inc_func.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" //действие 1 - включване на заглавния файл

// код Код::Блокове

// Dev-C++ код

// inc_func.cpp: Дефинира входната точка за конзолното приложение. // действие 1 - включване на заглавния файл който съдържа прототипи на основни математически функции #include int main(int argc, char* argv) ( float power = pow(3.14,2); //действие 2 - изпълнение на функцията за повишаване на число до връщане на степен 0; )

Включването на заглавни файлове се извършва, както е показано в ред 5, т.е. директивата на препроцесора #include се декларира, след което вътре в знаците<>изписва се името на заглавния файл. Когато е включен заглавният файл, можете да използвате функцията, което се прави в ред 9.Функцията pow() повдига число 3.14 на квадрат и присвоява получения резултат на степенната променлива, където
pow — име на функция;
числата 3.14 и 2 са аргументи на функцията;

Името на функцията винаги е последвано от скоби, в които се предават аргументите на функцията, а ако има няколко аргумента, те се отделят един от друг със запетаи. Необходими са аргументи, за да могат функциите да предават информация. Например, за да поставите на квадрат числото 3,14 с помощта на функцията pow(), трябва по някакъв начин да кажете на тази функция какво число е и на каква степен да го повдигне. Точно затова са измислени аргументите на функцията, но има функции, в които аргументите не се предават; такива функции се извикват с празни скоби. И така, за да използвате функция от стандартния C++ заглавен файл, трябва да изпълните две стъпки:

1. Включете необходимия заглавен файл;
2. Стартирайте желаната функция.

В допълнение към извикване на функции от стандартни заглавни файлове, езикът за програмиране C++ предоставя възможност за създаване на ваши собствени функции. В езика за програмиране C++ има два типа функции:

1. Функции, които не връщат стойности
2. Функции, които връщат стойност

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

// структура на декларация на функции, които не връщат стойности void /*име на функция*/(/*параметри на функция*/) // заглавка на функция ( // тяло на функция)

Ред 2започва със запазената дума void е тип данни, който не може да съхранява никакви данни. Типът данни void означава, че тази функция не връща никакви стойности. void няма друга употреба и е необходим само за да може компилаторът да определи типа на функцията. След запазената дума void се изписва името на функцията. Непосредствено след името на функцията има две скоби, една отваряща и една затваряща. Ако дадена функция трябва да прехвърли някакви данни, тогава параметрите на функцията се декларират в скоби, те се разделят един от друг със запетаи. Ред 2 се нарича заглавка на функцията. След заглавката на функцията се записват две фигурни скоби, вътре в които има алгоритъм, наречен тяло на функцията. Нека разработим програма, в която декларираме функция за намиране на факториела, като функцията не трябва да връща стойност.

<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult cout << numb << "! = " << rezult << endl; // печать значения n! } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> цифра;

// код Код::Блокове

// Dev-C++ код

faktorial(цифра);//стартира функцията за намиране на факториалната система("пауза");<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult cout << numb << "! = " << rezult << endl; // печать значения n! } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >връщане 0; )

използване на пространство от имена std; // декларация на функция за намиране на n! void faktorial(int numb) // заглавка на функция ( int rezult = 1; // инициализиране на променливата rezult със стойност 1 за (int i = 1; i > цифра; faktorial(цифра);//изпълнение на функцията за намиране на факториел връща 0; ) След като всички необходими заглавни файлове са включени, можете да декларирате функция за намиране на факториел Под деклариране на функция имаме предвид избор на име на функцията, дефиниране на параметрите на функцията и писане на алгоритъма, който е тялото на функцията. . След като изпълните тези стъпки, функцията може да се използва в програмата. Тъй като функцията не трябва да връща стойност, типът на връщането трябва да е void. Името на функцията е faktorial, вътре в скобите е декларирана променливата numb от тип int. Тази променлива е параметър на функцията faktorial(). По този начин всички реклами вред 8 заедно те съставляват заглавката на функцията. Редове 9 - 14 съставляват тялото на функцията faktorial(). Вътре в тялото, ред 10 декларира променливата rezult, която ще съхранява резултата от намирането на n! След което, вредове 11-12 Деклариран е оператор за цикъл за намиране на факториела. INред 13

Декларира се операторът cout, с помощта на който на екрана ще се изведе стойността на факториела. Сега, когато функцията е декларирана, можете да я използвате. IN

ред 21

Функцията faktorial(digit) се стартира, аргументът се предава във функционалните скоби, т.е. стойността, съдържаща се в променливата digit. Резултатът от програмата (вижте Фигура 1).

Фигура 1 - Функции в C++

Структурата на декларациите на функции остава почти непроменена, с изключение на два реда. В заглавката на функцията първо трябва да дефинирате типа данни за връщане, това може да бъде тип данни int, ако искате да върнете цяло число, или тип данни float за числа с плаваща запетая. Като цяло, всеки друг тип данни, всичко зависи от това какво трябва да върне функцията. Тъй като функцията трябва да върне стойност, трябва да се осигури специален механизъм за това, както в ред 5. Като използвате запазената дума return, можете да върнете стойност, когато функцията завърши. Всичко, което е необходимо, е да посочите променлива, съдържаща желаната стойност, или някаква стойност, след оператора return. Тип данни за върната стойност ред 5трябва да съответства на типа данни в линия 2. Нека преработим програмата за намиране на факториела, така че функцията faktorial() да връща стойността на факториела.

// struct_func.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" #include <= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult return rezult; // передаём значение факториала в главную функцию } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> цифра;<< digit << "! = " << faktorial(digit) << endl;// запуск функции нахождения факториала system("pause"); return 0; }

// код Код::Блокове

// Dev-C++ код

cout // struct_func.cpp: Дефинира входната точка за конзолното приложение. #включи<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult return rezult; // передаём значение факториала в главную функцию } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> цифра;<< digit << "! = " << faktorial(digit) << endl;// запуск функции нахождения факториала return 0; }

използване на пространство от имена std; // декларация на функция за намиране на n! int faktorial(int numb) // заглавка на функцията ( int rezult = 1; // инициализиране на променливата rezult със стойност 1 за (int i = 1; i заедно те съставляват заглавката на функцията. Редове 9 - 14 съставляват тялото на функцията faktorial(). Вътре в тялото, ред 10 декларира променливата rezult, която ще съхранява резултата от намирането на n! След което, вФункцията faktorial() вече има тип данни за връщане int, защото n! е цяло число.B Деклариран е оператор за цикъл за намиране на факториела. INдекларира се оператор return, който връща стойността, съдържаща се в променливата rezult. IN Изпълняваме функцията faktorial(), чиято върната стойност се изпраща към изходния поток с помощта на оператора cout. Може да се напише така: int fakt = faktorial(digit); - тип променливавътр

присвояваме върнатата стойност на функцията faktorial(), след което променливата fakt ще съхрани стойността n! . Резултатът от програмата не се е променил (вижте Фигура 2).

Въведете номер: 5 5! = 120 За да продължите, натиснете произволен клавиш. . .

Фигура 2 - Функции в C++

Разгледахме два типа функции и декларирането на функциите беше извършено в програмната област, след включването на заглавните файлове, но преди началото на функцията main(). Има няколко начина за деклариране на функции (вижте Фигура 3).

Фигура 3 - Функции в C++ включенопоказва 4 начина за деклариране на функции в езика за програмиране C++. Нека да разгледаме структурата на декларациите на функции в един файл с основната функция. Функциите могат да бъдат декларирани в две области, преди функцията main() и след функцията main(). Досега сме декларирали функции в един файл, преди функцията main() - това е най-простият начин.

// struct_func.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" /*област 1 - декларация на функции преди началото на main(), място за деклариране на функции, декларирани в тази област, не се нуждаят от прототипи */ int main(int argc, char* argv) (върни 0;)

Ако функциите са декларирани в регион 1, преди основната функция, тогава не са необходими прототипи за тези функции. Добър стил на програмиране е да декларирате функции след main(). Нека да разгледаме структурата на такава декларация на функция.

// struct_func.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" // място за деклариране на прототипи на функции int main(int argc, char* argv) ( return 0; ) /*област 2 - деклариране на функции след main() място за деклариране на функции */

// код Код::Блокове

// Dev-C++ код

// struct_func.cpp: Дефинира входната точка за конзолното приложение. // място за деклариране на прототипи на функции int main(int argc, char* argv) ( return 0; ) /*област 2 - деклариране на функции след main() място за деклариране на функции */

Областта за деклариране на функции се премести в самия край на програмата, след main() . Що се отнася до самия метод за деклариране на функции, той не се е променил. Но тъй като функциите са декларирани след main(), няма да е възможно да ги използвате, тъй като редът на декларациите е променен и функцията main() просто няма да види функциите, декларирани след. И така, за да могат тези функции да бъдат видими в main(), съществува концепцията за прототип. Прототипът на функция е заглавка на функция, която е декларирана преди функцията main(). И ако декларирате прототип на функция, тогава функцията може да се види в main().

// синтаксис на декларация на прототип /*функция връща тип данни*/ /*име на функция*/(/*функционални параметри*/);

Структурата на декларация на прототип е много подобна на структурата на декларация на функция. Нека разработим програма, която определя дали въведеното петцифрено число е палиндром. Палиндромът е число или текст, който се чете по един и същи начин отляво и отдясно: 93939; 49094; 11311.

// palindrom_func.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" #include << "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >> << "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

// код Код::Блокове

// Dev-C++ код

// palindrom_func.cpp: Дефинира входната точка за конзолното приложение. #включи използване на пространство от имена std; bool palindrome5(int); // прототип на функцията за намиране на палиндром от петцифрени числа int main(int argc, char* argv) ( cout<< "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>в_номер;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

out_number = in_number; // съхранява въведеното число в променливата out_number if (palindrom5(in_number)) // ако функцията върне true, тогава условието е true, в противен случай функцията ще върне false - false cout INлиния 7 беше обявена прототипна функция за намиране на палиндром от петцифрени числа. Моля, обърнете внимание, че прототипът трябва напълно да съответства на заглавката на функцията, но все още има някои разлики. Например, прототипът не трябва да изброява имената на параметрите; достатъчно е да декларирате техните типове данни. Винаги трябва да поставяте точка и запетая в края на декларация на прототип. В противен случай декларацията на прототипа е същата като декларацията на заглавката на отделна функция. Прототипът трябва да се декларира за всяка функция поотделно. Променливата out_number се използва за временно съхраняване на въведеното число. INред 16 условието на израза за избор на if изпълнява функцията palindrom5(). Аргументът за него е променливата in_number. функцията ще върне стойност от тип bool и ако функцията върне true, тогава условието ще бъде true, в противен случай ще бъде false. Би било възможно първо да присвоите стойността, върната от функцията, на някаква променлива и след това да замените тази променлива в условието на израза за избор на if, но това ще увеличи програмния код с един ред. INредове 23 - 40 Декларира се функцията palindrom5() с един параметър, чрез който на функцията се предава петцифрено число. Променливите баланс1, баланс2, баланс4, баланс5 са декларирани вред 25 , и са необходими за съхраняване на цифрите на петцифрено число: първо, второ, четвърто, пето (номериране - от дясно на ляво). В редове 26, 29, 32, 35 се извършва същата операция - остатък от делението. Операцията за остатък от деление отрязва един бит отдясно наляво и ги съхранява съответно в променливите баланс1, баланс2, баланс4, баланс5. Освен това операцията остатък от деление се редува с операцията на обикновено деление. Операцията за разделяне се извършва в, 30 , 33 редове 27 , и намалява въведеното петцифрено число на стъпки с по една цифра. INред 30 Операцията за деление намалява въведеното число с две цифри наведнъж, тъй като числото е петцифрено и средната цифра не ни интересува, може да бъде всичко. INдекларира се оператор за избор if , който сравнява цифрите на петцифрено число и ако те са съответно равни, тогава функцията ще върне true , в противен случай false . Резултатът от програмата (виж Фигура 4).

Въведете номер 5zn-e: 12321 Номер 12321 - палендром За да продължите, натиснете произволен клавиш. . .

Фигура 4 - Функции в C++

Досега сме декларирали функции в същия файл като основната програма, тоест там, където се намира функцията main(). В C++ е възможно да поставите декларации на функции в отделен файл, тогава ще трябва да включите файла с функциите, както е в случая с включването на стандартни заглавни файлове. Има два начина:

1. създаване на *.cpp файл, в който се декларират функции;
2. създаване на *.cpp и *.h файлове.

Вторият метод е добър стил на програмиране. Така, ако декларирате функции в друг файл, направете го според втория метод. Нека преработим програмата за намиране на палиндром, така че декларацията на функцията palindrom5() да е в отделен *.cpp файл. Файлът *.h е необходим, за да се скрие изпълнението на функции, т.е. файлът *.h ще съдържа прототипи на функции. Използвайки MVS Solution Explorer, създайте *.h файл и го наречете palendrom.

// файлов код palendrom.h #ifndef palendrom #define palendrom bool palindrom5(int); // прототип на функцията за намиране на палиндром от петцифрени числа #endif

Директиви в редове 2,3,5винаги трябва да се декларират във файлове с прототипи на функции, а прототипите на функции винаги се декларират в *.h файлове. След директивите, написани в редове 2,3, но прототипите на функциите се декларират преди директивата #endif. Ред 4 декларира прототипа на функцията palindrom5(). Декларацията на тази функция е във файла palendrom.cpp, който също беше създаден преди с помощта на MVS Solution Explorer.

// съдържание на файла palendrom.cpp #include "stdafx.h" #include "palendrom.h" bool palindrom5(int number) // функция за намиране на палиндрома на петцифрени числа ( int balance1, balance2, balance4, balance5 ; // променливи, съхраняващи междинни резултати = число % 10; // присвоено е число на променливата остатък = число / 10; // присвоено е въведеното число = число % 10 второ число = число / 100; число с две цифри = число % 10; // на променливата остатък = число / 10; на променлива баланс5 се присвоява петият остатък, ако ((баланс1 == баланс5) && (баланс2 == баланс4)) връща вярно; // функцията връща вярна стойност, иначе връща фалшива стойност)

// код Код::Блокове

// Dev-C++ код

// съдържание на файла palendrom.cpp #include "palendrom.h" bool palindrom5(int number) // функция за намиране на палиндрома от петцифрени числа ( int balance1, balance2, balance4, balance5; // променливи, съхраняващи междинни резултати баланс1 = число % 10; // на променливата баланс1 е присвоен първи остатък номер = число / 10; // намаление на въведеното число с една цифра баланс2 = число % 10; // на променлива баланс2 е присвоен вторият остатък номер = число / 100 ; // намаляване на въведеното число с две цифри = число % 10; // променливото салдо4 получава четвъртото число на остатъка / 10; // намаляване на въведеното число с едноцифрено салдо 5 = число % 10 се присвоява петият остатък, ако ((balance1 == balance5) && (balance2 == balance4)) return true; // функцията връща true value else return false; // функцията връща false value )

Файлът palendrom.cpp съдържа декларация на функцията palindrom5(). Тъй като файлът palendrom.cpp е изпълним файл (*.cpp са изпълними файлове), е необходимо да включите контейнера "stdafx.h" в него, както в линия 2. За да свържете файла, където е декларирана функцията palindrom5() и файла с неговия прототип, нека включим заглавния файл (файла с прототипа), това се прави в ред 3. Моля, обърнете внимание, че при свързване на създадения от нас файл се използват двойни кавички, а не знаци за по-голямо или по-малко от. Всичко, което остава, е да стартирате функцията palindrom5() в главния изпълним файл func_palendrom.cpp.

// func_palendrom.cpp: Дефинира входната точка за конзолното приложение. #include "stdafx.h" #include << "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>в_номер;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

// код Код::Блокове

// Dev-C++ код

// func_palendrom.cpp: Дефинира входната точка за конзолното приложение. #включи // включване на заглавния файл с прототипа на функцията palindrom5() #include "palendrom.h" с използване на namespace std; int main(int argc, char* argv) ( cout<< "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>в_номер;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

out_number = in_number; // съхранява въведеното число в променливата out_number if (palindrom5(in_number)) // ако функцията върне true, тогава условието е true, в противен случай функцията ще върне false - false cout ред 6включихме файл с прототип на функцията palindrom5(), след което можем да използваме тази функция. И така, разделихме програмата на три файла:

• файл на проекта: func_palendrom.cpp
• заглавен файл palendrom.h
• изпълним файл palendrom.cpp

Свързваме файла на проекта със заглавния файл и свързваме заглавния файл с изпълнимия файл, в който случай файлът на проекта ще види функцията palindrom5() и ще може да я изпълни.