Meniu

Funcții în C ++ cu tipuri și exemple

functions c with types examples

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Tipuri de funcții în C ++ împreună cu utilizările lor.

În tutorialele noastre anterioare de până acum, am văzut diferitele concepte în C ++ precum variabile, clase de stocare, operatori, tablouri, șiruri etc.

În acest tutorial, vom merge mai departe și vom discuta despre conceptul de funcții. Funcțiile sunt, de asemenea, numite metode, subrutine sau proceduri.

=> Citiți aici seria de tutoriale extinse de formare C ++.

FUNCȚII ÎN C ++

Ce veți învăța:

Cum definim o funcție?

O funcție este un set de instrucțiuni care sunt puse împreună pentru a efectua o sarcină specifică. Poate fi declarații care efectuează unele sarcini repetate sau instrucțiuni care efectuează unele sarcini de specialitate, cum ar fi imprimarea etc.

O utilizare a funcțiilor este simplificarea codului prin divizarea acestuia în unități mai mici numite funcții. O altă idee din spatele utilizării funcțiilor este că ne scutește de a scrie același cod din nou și din nou. Trebuie doar să scriem o funcție și apoi să o numim așa cum și când este necesar, fără a fi nevoie să scriem același set de instrucțiuni din nou și din nou.

Tipuri de funcții în C ++

În C ++, avem două tipuri de funcții așa cum se arată mai jos.

Tipuri de funcții în C ++

Funcții încorporate

Funcțiile încorporate sunt numite și funcții de bibliotecă. Acestea sunt funcțiile furnizate de C ++ și nu trebuie să le scriem singuri. Putem folosi direct aceste funcții în codul nostru.

Aceste funcții sunt plasate în fișierele antet ale C ++. De exemplu ,, sunt anteturile care au funcții matematice încorporate și, respectiv, funcții șir.

Să vedem un exemplu de utilizare a funcțiilor încorporate într-un program.

#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 : '<

Ieșire:

Introduceți șirul de intrare: Ajutor pentru testarea software-ului
Șir introdus: Testare software Ajutor!
Dimensiunea șirului: 21

Aici folosim anteturile și. Tipurile de date și alte funcții de intrare / ieșire sunt definite în bibliotecă. Funcțiile șir utilizate ca getline, dimensiunea fac parte din antet.

Funcții definite de utilizator

C ++ le permite utilizatorilor să-și definească propriile funcții. Acestea sunt funcțiile definite de utilizator. Putem defini funcțiile oriunde în program și apoi să apelăm aceste funcții din orice parte a codului. La fel ca variabilele, ar trebui să fie declarate înainte de utilizare, funcțiile trebuie, de asemenea, declarate înainte de a fi apelate.

Să discutăm în detaliu funcțiile definite de utilizator.

Sintaxa generală pentru funcțiile definite de utilizator (sau pur și simplu funcțiile) este cea prezentată mai jos:

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

Așa cum se arată mai sus, fiecare funcție are:

  • Tipul de returnare: Este valoarea pe care funcțiile o revin la funcția de apelare după efectuarea unei sarcini specifice.
  • functionName : Identificator folosit pentru denumirea unei funcții.
  • Lista parametrilor: Notat cu param1, param2, ... paramn în sintaxa de mai sus. Acestea sunt argumentele care sunt transmise funcției atunci când se efectuează un apel de funcție. Lista parametrilor este opțională, adică putem avea funcții care nu au parametri.
  • Corpul funcției: Un grup de afirmații care îndeplinesc o sarcină specifică.

După cum sa menționat deja, trebuie să „declarăm” o funcție înainte de ao utiliza.

Declarația funcției

O declarație de funcție spune compilatorului despre tipul de funcție returnat, numărul de parametri utilizați de funcție și tipurile sale de date. Incluzând numele parametrilor în funcție, declarația este opțională. Declarația funcției este numită și ca prototip de funcție.

Am dat câteva exemple ale declarației de funcții de mai jos pentru referință.

int sum(int, int);

Declarația de mai sus este o funcție „sumă” care ia doi parametri întregi ca parametri și returnează o valoare întreagă.

void swap(int, int);

Aceasta înseamnă că funcția de swap ia doi parametri de tip int și nu returnează nicio valoare și, prin urmare, tipul de returnare este nul.

void display();

Afișarea funcției nu ia niciun parametru și, de asemenea, nu returnează niciun tip.

Definiția funcției

O definiție a funcției conține tot ceea ce conține o declarație de funcție și, de asemenea, conține corpul funcției închise între paranteze ({}).

În plus, ar trebui să aibă și parametri numiți. Când funcția este apelată, controlul programului trece la definiția funcției, astfel încât codul funcției să poată fi executat. Când executarea funcției este terminată, controlul trece înapoi la punctul în care funcția a fost apelată.

Pentru declarația de mai sus a funcției de swap, definiția este cea dată mai jos:

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

Rețineți că declarația și definiția unei funcții pot merge împreună. Dacă definim o funcție înainte de a o face referire atunci nu este nevoie de o declarație separată.

Să luăm un exemplu complet de programare pentru a demonstra o funcție.

#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 = '< Apelarea unei funcții

Când avem o funcție în programul nostru, atunci în funcție de cerință trebuie să apelăm sau să invocăm această funcție. Numai când funcția este apelată sau invocată, funcția își va executa setul de instrucțiuni pentru a furniza rezultatele dorite.

Funcția poate fi apelată de oriunde din program. Poate fi apelat din funcția principală sau din orice altă funcție dacă programul folosește mai multe funcții. Funcția care apelează o altă funcție se numește „Funcția de apelare”.

În exemplul de mai sus de swapping numerele, funcția swap este apelată în funcția principală. Prin urmare, funcția principală devine funcția de apelare.

Parametri formali și actuali

Am văzut deja că putem avea parametri pentru funcții. Parametrii funcției sunt furnizați în definiția funcției ca o listă de parametri care urmează numele funcției. Când funcția este apelată, trebuie să trecem valorile reale ale acestor parametri, astfel încât, folosind aceste valori reale, funcția să își poată îndeplini sarcina.

Se numesc parametrii definiți în definiția funcției Parametri formali . Se apelează parametrii din apelul de funcție care sunt valorile reale Parametri reali.

În exemplul de mai sus de schimbare a numerelor, am scris comentariile pentru parametrii formali și reali. În funcția de apelare, adică principală, valoarea a două numere întregi este citită și transmisă funcției de swap. Aceștia sunt parametrii reali.

Putem vedea definițiile acestor parametri în prima linie a definiției funcției. Aceștia sunt parametrii formali.

Rețineți că tipul de argumente formale și reale ar trebui să se potrivească. De asemenea, ar trebui să se potrivească ordinea parametrilor formali și reali.

Valori returnate

Odată ce funcția își îndeplinește sarcina intenționată, ar trebui să returneze rezultatul la funcția de apelare. Pentru aceasta, avem nevoie de tipul returnat al funcției. Funcția poate returna o singură valoare funcției de apelare. Tipul returnat al funcției este declarat împreună cu prototipul funcției.

c ++ generează un număr aleatoriu între 1 și 10

Să luăm un exemplu de adăugare a două numere pentru a demonstra tipurile de returnare.

#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 : '<

Ieșire:

Introduceți cele două numere de adăugat: 11 11

Suma celor două numere: 22

În exemplul de mai sus, avem o sumă funcțională care ia doi parametri întregi și returnează un tip întreg. În funcția principală, citim două numere întregi din intrarea consolei și le transmitem funcției sumă. Deoarece tipul de returnare este un număr întreg, avem o variabilă de rezultat pe LHS, iar RHS este un apel funcțional.

Când se execută o funcție, expresia (a + b) returnată de suma funcției este atribuită variabilei rezultate. Aceasta arată cum este utilizată valoarea de returnare a funcției.

Funcții de vid

Am văzut că sintaxa generală a funcției necesită definirea unui tip de returnare. Dar dacă în cazul în care avem o astfel de funcție care nu returnează nicio valoare, în acest caz, ce specificăm ca tip de returnare? Răspunsul este că folosim tipul fără valoare „void” pentru a indica faptul că funcția nu returnează o valoare.

Într-un astfel de caz funcția se numește „funcție nulă” și prototipul său va fi ca.

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

Notă : Se consideră o bună practică includerea unei declarații „returnare”; la sfârșitul funcției de gol pentru claritate.

Transmiterea parametrilor la funcții

Am văzut deja conceptul de parametri reali și formali. Știm, de asemenea, că parametrii reali transmit valori către o funcție care este primită de parametrii de format. Aceasta se numește trecerea parametrilor.

În C ++, avem anumite modalități de a transmite parametrii așa cum este discutat mai jos.

Treceți după valoare

În programul de a schimba două numere întregi pe care le-am discutat mai devreme, am văzut că tocmai am citit numere întregi „a” și „b” în principal și le-am trecut la funcția de swap. Aceasta este tehnica de trecere prin valoare.

În tehnica de trecere a valorii de trecere a parametrilor, copiile valorilor parametrilor reali sunt transmise parametrilor formali. Datorită acestui fapt, parametrii reali și formali sunt stocați în locații de memorie diferite. Astfel, modificările aduse parametrilor formali din interiorul funcției nu se reflectă în afara funcției.

Putem înțelege mai bine acest lucru vizitând din nou schimbul a două numere.

#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 = '< Treceți de referință

Trecerea prin referință este încă o altă tehnică utilizată de C ++ pentru a transmite parametrii funcțiilor. În această tehnică, în loc să trecem copii ale parametrilor reali, trecem referințe la parametrii reali.

Notă: Referințele nu sunt altceva decât aliasuri ale variabilelor sau, în cuvinte simple, este un alt nume care este dat unei variabile. Prin urmare, o variabilă și referința ei au aceeași locație de memorie. Vom afla referințe în detaliu în tutorialul nostru ulterior.

În tehnica de trecere prin referință, folosim aceste referințe ale parametrilor reali și, ca rezultat, modificările aduse parametrilor formali din funcție sunt reflectate înapoi la funcția de apelare.

Modificăm funcția de swap pentru ca cititorii noștri să înțeleagă mai bine conceptul.

#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 = '< Treceți pe lângă Pointer

În C ++, putem trece și parametrii pentru a funcționa folosind variabilele pointer. Tehnica trecere prin pointer produce aceleași rezultate ca și trecerea prin referință. Aceasta înseamnă că atât parametrii formali, cât și cei reali au aceleași locații de memorie, iar modificările efectuate în funcție sunt reflectate în funcția de apelare.

Singura diferență că într-o trecere prin referință ne ocupăm de referințe sau aliasuri de parametri, în timp ce într-o tehnică de trecere prin pointer folosim variabile de pointer pentru a trece parametrii.

Variabilele pointer diferă în funcție de referințele în care variabilele pointer indică o anumită variabilă și spre deosebire de referințe, putem schimba variabila către care indică. Vom explora detaliile indicatorului în tutorialele noastre ulterioare.

Prezentăm schimbul a două numere întregi din nou pentru a demonstra tehnica Pass by Pointer.

#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 = '< Parametri impliciti

În C ++, putem furniza valori implicite pentru parametrii funcției. În acest caz, când invocăm funcția, nu specificăm parametri. În schimb, funcția ia parametrii impliciți care sunt furnizați în prototip.

Următorul exemplu demonstrează utilizarea parametrilor impliciți.

#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<

Ieșire:

Introduceți valorile pentru a, b și c: 10 4 6

Apelați la operația matematică cu 1 arg: 15
Apelați la operația matematică cu 2 arg: 20
Apelați la operația matematică cu 3 arg: 6

Așa cum se arată în exemplul de cod, avem o funcție „matematică” care ia trei parametri din care am furnizat valori implicite pentru doi parametri. Apoi, în funcția principală, numim această funcție de trei ori cu o listă diferită de argumente.

Primul apel este cu un singur argument. În acest caz, celelalte două argumente vor avea valori implicite. Următorul apel este cu două argumente. În acest caz, al treilea argument va avea o valoare implicită. Al treilea apel este cu trei argumente. În acest caz, deoarece am furnizat toate cele trei argumente, valorile implicite vor fi ignorate.

Rețineți că, în timp ce furnizați parametrii impliciți, pornim întotdeauna de la parametrul din dreapta. De asemenea, nu putem sări peste un parametru între și să oferim o valoare implicită pentru următorul parametru.

Acum, să trecem la câteva concepte speciale legate de funcții, care sunt importante din punctul de vedere al programatorului.

Parametrii Const

De asemenea, putem transmite parametri constanți funcțiilor folosind cuvântul cheie „const”. Când un parametru sau referință este const, acesta nu poate fi modificat în interiorul funcției.

Rețineți că nu putem trece un parametru const unui parametru formal non-const. Dar putem trece parametrii const și non-const la un parametru formal const.

În mod similar, putem avea și const return-type. De asemenea, în acest caz, tipul de returnare nu poate fi modificat.

Să vedem un exemplu de cod care utilizează referințe 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 = '<

Ieșire:

Introduceți cele două numere care vor fi schimbate: 22 33
a = 2 b = 33
Rezultatul adunării: 55

În programul de mai sus, avem parametri constanți. Rețineți că parametrii reali sunt variabile obișnuite non-const pe care le-am trecut cu succes. Deoarece parametrii formali sunt constanți, nu îi putem modifica în interiorul funcției. Deci, doar efectuăm operația de adăugare și returnăm valoarea.

Dacă încercăm să modificăm valorile lui a sau b din interiorul funcției, atunci compilatorul va emite o eroare.

Funcții Inline

Știm că, pentru a efectua un apel funcțional, intern implică un compilator care stochează starea programului pe o stivă înainte de a trece controlul funcției.

Când funcția revine, compilatorul trebuie să recupereze starea programului înapoi și să continue de unde a plecat. Acest lucru reprezintă o suprasolicitare. Prin urmare, în C ++ ori de câte ori avem o funcție constând din câteva instrucțiuni, există o facilitate care îi permite să se extindă în linie. Acest lucru se face făcând o funcție în linie.

Deci, funcțiile în linie sunt funcțiile care sunt extinse în timpul rulării, economisind eforturile de a apela funcția și de a face modificările stivei. Dar chiar dacă facem o funcție în linie, compilatorul nu garantează că va fi extins la runtime. Cu alte cuvinte, este complet dependent de compilator pentru a face funcția în linie sau nu.

Unele compilatoare detectează funcții mai mici și le extind în linie chiar dacă nu sunt declarate în linie.

Următorul este un exemplu de funcție Inline.

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

Așa cum se arată mai sus, precedăm definiția funcției cu un cuvânt cheie „inline” pentru a face o funcție inline.

Utilizarea structurilor în funcții

Putem trece variabilele structurii ca parametri pentru a funcționa într-un mod similar în care trecem variabilele obișnuite ca parametri.

Acest lucru este prezentat în următorul exemplu.

#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); }

Ieșire:

Introduceți numele: Vedang
Introduceți vârsta: 22
Introduceți salariul: 45000,00
Structura PersonInfo:
Vârstă: 22 de ani
Nume: Vedang
Salariu: 45000

Utilizarea structurilor în funcții - Ieșire

Așa cum se arată în programul de mai sus, trecem o structură pentru a funcționa în mod similar cu alte variabile. Citim valorile pentru membrii structurii din intrarea standard și apoi transmitem o structură unei funcții care afișează structura.

Concluzie

Totul a fost despre noțiunile de bază ale funcțiilor în C ++.

Vom explora mai multe despre funcțiile statice în C ++ în tutorialele noastre viitoare.

=> Verificați aici seria completă de antrenament GRATUIT C ++.

Lectură recomandată

^