Меню

Функции в C ++ с типове и примери

functions c with types examples

Опитайте Нашия Инструмент За Премахване На Проблемите

Видове функции в C ++ заедно с тяхното използване.

В по-ранните ни уроци досега сме виждали различните концепции в C ++ като променливи, класове за съхранение, оператори, масиви, низове и т.н.

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

=> Прочетете обширната серия учебни уроци за C ++ тук.

ФУНКЦИИ В С ++

Какво ще научите:

Как определяме функция?

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

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

Видове функции в C ++

В C ++ имаме два типа функции, както е показано по-долу.

Видове функции в C ++

Вградени функции

Вградените функции се наричат ​​още библиотечни функции. Това са функциите, които се предоставят от C ++ и не е необходимо да ги записваме сами. Можем директно да използваме тези функции в нашия код.

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

Нека видим Пример за използване на вградени функции в програма.

#include #include using namespace std; int main() { string name; cout << 'Enter the input string:'; getline (std::cin, name); cout << 'String entered: ' << name << '! '; int size = name.size(); cout<<'Size of string : '<

Изход:

Въведете входния низ: Помощ за тестване на софтуер
Въведен низ: Помощ за тестване на софтуер!
Размер на струната: 21

Тук използваме заглавките и. Типовете данни и другите функции за вход / изход са дефинирани в библиотеката. Функциите на низовете, използвани като getline, size, са част от заглавката.

Дефинирани от потребителя функции

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

Нека обсъдим детайлно дефинираните от потребителя функции.

Общият синтаксис за дефинирани от потребителя функции (или просто функции) е даден по-долу:

return_type functionName(param1,param2,….param3) { Function body; }

Както е показано по-горе, всяка функция има:

  • Тип връщане: Това е стойността, която функциите се връщат към извикващата функция след изпълнение на определена задача.
  • functionName : Идентификатор, използван за именуване на функция.
  • Списък с параметри: Обозначава се с param1, param2, ... paramn в горния синтаксис. Това са аргументите, които се предават на функцията при извършване на извикване на функция. Списъкът с параметри не е задължителен, т.е.можем да имаме функции, които нямат параметри.
  • Функция тяло: Група изявления, които изпълняват конкретна задача.

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

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

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

Дадохме няколко примера за декларацията на функциите по-долу за ваша справка.

int sum(int, int);

Декларацията по-горе е на функция ‘sum’, която приема две цели числа като параметри и връща цяла стойност.

void swap(int, int);

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

void display();

Дисплеят на функциите не приема никакви параметри и също така не връща никакъв тип.

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

Дефиницията на функция съдържа всичко, което съдържа декларацията за функция, а освен това съдържа и тялото на функцията, затворена в скоби ({}).

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

За горната декларация за суап функция дефиницията е дадена по-долу:

void swap(int a, int b){ b = a + b; a = b - a; b = b - a; }

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

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

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping: '; cout<<'a = '< Извикване на функция

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

Функцията може да бъде извикана от всяко място в програмата. Може да се извика от основната функция или от която и да е друга функция, ако програмата използва повече от една функция. Функцията, която извиква друга функция, се нарича „Функция за повикване“.

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

Формални и действителни параметри

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

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

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

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

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

Възвръщаеми стойности

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

Да вземем пример за добавяне на две числа, за да демонстрираме типовете връщане.

#include using namespace std; int sum(int a, int b){ return (a+b); } int main() { int a, b, result; cout<>a>>b; result = sum(a,b); cout<<' Sum of the two numbers : '<

Изход:

Въведете двете числа, които ще добавите: 11 11

Сума от двете числа: 22

В горния пример имаме функционална сума, която взема два целочислени параметъра и връща цял тип. В основната функция четем две цели числа от входа на конзолата и ги предаваме на функцията sum. Тъй като типът на връщане е цяло число, имаме променлива на резултата на LHS и RHS е извикване на функция.

Когато се изпълнява функция, изразът (a + b), върнат от сумата на функцията, се присвоява на резултантната променлива. Това показва как се използва възвръщаемата стойност на функцията.

Функции за празнота

Видяхме, че общият синтаксис на функцията изисква да бъде дефиниран тип връщане. Но ако в случай че имаме такава функция, която не връща никаква стойност, в този случай, какво определяме като тип на връщане? Отговорът е, че използваме безполезен тип „void“, за да покажем, че функцията не връща стойност.

В такъв случай функцията се нарича „void function“ и нейният прототип ще бъде подобен

void functionName (param1, param2, ... .param 3);

Забележка : Счита се за добра практика да се включи изявление „връщане;“ в края на функцията void за яснота.

Предаване на параметри на функции

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

В C ++ имаме определени начини за предаване на параметри, както е обсъдено по-долу.

Предайте по стойност

В програмата за размяна на две цели числа, която обсъдихме по-рано, видяхме, че просто прочетохме цели числа „a“ и „b“ основно и ги предадохме на функцията за суап. Това е техниката на предаване на стойност.

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

Можем да разберем това по-добре, като отново посетим размяната на две числа.

#include using namespace std; void swap(int a, int b) { //here a and b are formal parameters b = a + b; a = b - a; b = b - a; cout<<' After swapping inside Swap: '; cout<<'a = '< Предайте от референцията

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

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

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

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

#include #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< Преминете покрай указателя

В C ++ ние също можем да предаваме параметрите да функционират, използвайки указателни променливи. Техниката за предаване чрез указател дава същите резултати като тази при преминаване чрез препратка. Това означава, че както официалните, така и действителните параметри споделят едни и същи местоположения в паметта и промените, направени във функцията, се отразяват във функцията за извикване.

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

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

Представяме отново размяната на две цели числа, за да демонстрираме техниката Pass by Pointer.

свързан възел на списък c ++
#include #include using namespace std; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { int a,b; cout<>a>>b; cout<<'a = '< Параметри по подразбиране

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

Следващият пример демонстрира използването на параметри по подразбиране.

#include #include using namespace std; int mathoperation(int a, int b = 3, int c = 2){ return ((a*b)/c); } int main() { int a,b,c; cout<>a>>b>>c; cout<

Изход:

Въведете стойности за a, b и c: 10 4 6

Обадете се на матоперация с 1 аргумент: 15
Обадете се на матоперация с 2 аргумента: 20
Обадете се на матоперация с 3 аргумента: 6

Както е показано в примера с кода, имаме функция ‘mathoperation’, която взема три параметъра, от които сме предоставили стойности по подразбиране за два параметъра. След това в основната функция извикваме тази функция три пъти с различен списък с аргументи.

Първото обаждане е само с един аргумент. В този случай другите два аргумента ще имат стойности по подразбиране. Следващото обаждане е с два аргумента. В този случай третият аргумент ще има стойност по подразбиране. Третото обаждане е с три аргумента. В този случай, както сме предоставили и трите аргумента, стойностите по подразбиране ще бъдат игнорирани.

Имайте предвид, че докато предоставяме параметри по подразбиране, винаги започваме от най-десния параметър. Също така не можем да пропуснем параметър между тях и да предоставим стойност по подразбиране за следващия параметър.

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

Параметри на Const

Също така можем да предаваме постоянни параметри на функции, използвайки ключовата дума ‘const’. Когато параметърът или препратката е const, той не може да бъде променен във функцията.

Обърнете внимание, че не можем да предадем параметър const на неконстален формален параметър. Но можем да предадем параметър const и non-const на формален параметър const.

По същия начин можем да имаме и const return-type. В този случай също типът на връщане не може да бъде модифициран.

Нека видим пример за код, който използва препратки const.

#include #include using namespace std; int addition(const int &a, const int &b){ return (a+b); } int main() { int a,b; cout<>a>>b; cout<<'a = '<

Изход:

Въведете двете числа, които ще се разменят: 22 33
a = 2 b = 33
Резултат от добавянето: 55

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

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

Вградени функции

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

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

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

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

Следва пример за вградена функция.

inline int addition(const int &a,const int &b){ return (a+b); }

Както е показано по-горе, ние предшестваме дефиницията на функцията с ключова дума “inline”, за да направим функцията вградена.

Използване на структури във функции

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

Това е показано в следващия пример.

#include #include using namespace std; struct PersonInfo { int age; char name(50); double salary; }; void printStructInfo(PersonInfo p) { cout<<'PersonInfo Structure:'; cout<<' Age:'< p.age; cout <> p.salary; printStructInfo(p); }

Изход:

Въведете име: Vedang
Въведете възраст: 22
Въведете заплата: 45000,00
Структура на PersonInfo:
Възраст: 22
Име: Веданг
Заплата: 45000

Използване на структури във функции - изход

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

Заключение

Това беше всичко за основите на функциите в C ++.

Ще проучим повече за статичните функции в C ++ в предстоящите ни уроци.

=> Проверете пълната C ++ БЕЗПЛАТНА серия за обучение тук.

Препоръчително четене

^