O funcție este un set de instrucțiuni care preia intrare, efectuează anumite calcule, și produce rezultate. Ideea este de a pune unele în mod obișnuit sau în mod repetat a făcut sarcini împreună pentru a face a funcţie astfel încât în loc să scriem același cod din nou și din nou pentru intrări diferite, putem apela această funcție.
În termeni simpli, o funcție este un bloc de cod care rulează numai atunci când este apelată.
Sintaxă:
Sintaxa funcției
Exemplu:
C++
// C++ Program to demonstrate working of a function> #include> using> namespace> std;> // Following function that takes two parameters 'x' and 'y'> // as input and returns max of two input numbers> int> max(>int> x,>int> y)> {> >if> (x>y)> >return> x;> >else> >return> y;> }> // main function that doesn't receive any parameter and> // returns integer> int> main()> {> >int> a = 10, b = 20;> >// Calling above function to find max of 'a' and 'b'> >int> m = max(a, b);> >cout <<>'m is '> << m;> >return> 0;> }> |
>
>Ieșire
m is 20>
Complexitatea timpului: O(1)
Complexitatea spațiului: O(1)
De ce avem nevoie de funcții?
- Funcțiile ne ajută să intrăm reducerea redundanței codului . Dacă funcționalitatea este realizată în mai multe locuri în software, atunci, în loc să scriem același cod, din nou și din nou, creăm o funcție și o numim peste tot. Acest lucru ajută, de asemenea, la întreținere, deoarece trebuie să facem modificări într-un singur loc dacă facem modificări funcționalității în viitor.
- Funcțiile fac cod modulare . Luați în considerare un fișier mare care are multe linii de cod. Devine foarte simplu să citiți și să utilizați codul, dacă codul este împărțit în funcții.
- Funcțiile oferă abstractizare . De exemplu, putem folosi funcțiile bibliotecii fără să ne facem griji pentru activitatea lor internă.
Declarație de funcție
O declarație de funcție îi spune compilatorului despre numărul de parametri, tipurile de date ale parametrilor și returnează tipul de funcție. Scrierea numelor de parametri în declarația funcției este opțională, dar este necesar să le puneți în definiție. Mai jos este un exemplu de declarații de funcție. (numele parametrilor nu sunt prezente în declarațiile de mai jos)
Declarație de funcție
Exemplu:
C++
// C++ Program to show function that takes> // two integers as parameters and returns> // an integer> int> max(>int>,>int>);> // A function that takes an int> // pointer and an int variable> // as parameters and returns> // a pointer of type int> int>* swap(>int>*,>int>);> // A function that takes> // a char as parameter and> // returns a reference variable> char>* call(>char> b);> // A function that takes a> // char and an int as parameters> // and returns an integer> int> fun(>char>,>int>);> |
>
>
Tipuri de funcții
Tipuri de funcții în C++
Funcție definită de utilizator
Funcțiile definite de utilizator sunt blocuri de cod definite de utilizator/client, special personalizate pentru a reduce complexitatea programelor mari. Ele sunt, de asemenea, cunoscute ca funcții personalizate care sunt construite doar pentru a satisface condiția în care utilizatorul se confruntă cu probleme reducând între timp complexitatea întregului program.
Funcția de bibliotecă
Sunt numite și funcțiile bibliotecii Funcții încorporate . Aceste funcții fac parte dintr-un pachet compilator care este deja definit și constă dintr-o funcție specială cu semnificații speciale și diferite. Funcția încorporată ne oferă un avantaj, deoarece le putem folosi direct fără a le defini, în timp ce în funcția definită de utilizator trebuie să declarăm și să definim o funcție înainte de a le folosi.
De exemplu: sqrt(), setw(), strcat(), etc.
Trecerea parametrilor la funcții
Parametrii trecuți funcției sunt apelați parametrii efectivi . De exemplu, în programul de mai jos, 5 și 10 sunt parametri reali.
Parametrii primiți de funcție sunt apelați parametri formali . De exemplu, în programul de mai sus, x și y sunt parametri formali.
Parametrul formal și parametrul real
Există două modalități cele mai populare de a trece parametri:
- Treci după valoare: În această metodă de trecere a parametrilor, valorile parametrilor actuali sunt copiate în parametrii formali ai funcției. Parametrii actuali și formali sunt stocați în diferite locații de memorie, astfel încât orice modificări făcute în funcții nu sunt reflectate în parametrii actuali ai apelantului.
- Treci prin referință: Atât parametrii actuali, cât și cei formali se referă la aceleași locații, astfel încât orice modificări făcute în interiorul funcției sunt reflectate în parametrii actuali ai apelantului.
Definiția funcției
Treci prin valoare este folosit acolo unde valoarea lui x nu este modificată folosind funcția fun().
C++
// C++ Program to demonstrate function definition> #include> using> namespace> std;> void> fun(>int> x)> {> >// definition of> >// function> >x = 30;> }> int> main()> {> >int> x = 20;> >fun(x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Ieșire
x = 20>
Complexitatea timpului: O(1)
Complexitatea spațiului: O(1)
Funcții folosind pointeri
Funcția fun() așteaptă un pointer ptr către un număr întreg (sau o adresă a unui număr întreg). Modifică valoarea la adresa ptr. Operatorul de dereferire * este folosit pentru a accesa valoarea la o adresă. În instrucțiunea „*ptr = 30”, valoarea la adresa ptr este schimbată la 30. Operatorul de adresă & este folosit pentru a obține adresa unei variabile de orice tip de date. În instrucțiunea de apelare a funcției „fun(&x)”, adresa lui x este transmisă astfel încât x să poată fi modificat folosind adresa sa.
C++
// C++ Program to demonstrate working of> // function using pointers> #include> using> namespace> std;> void> fun(>int>* ptr) { *ptr = 30; }> int> main()> {> >int> x = 20;> >fun(&x);> >cout <<>'x = '> << x;> >return> 0;> }> |
>
>Ieșire
x = 30>
Complexitatea timpului: O(1)
Complexitatea spațiului: O(1)
Diferența dintre apelul după valoare și apelul prin referință în C++
| Apel după valoare | Sună prin referință |
|---|---|
| O copie a valorii este transmisă funcției | O adresă de valoare este transmisă funcției |
| Modificările făcute în interiorul funcției nu sunt reflectat asupra altor funcţii | Modificările efectuate în interiorul funcției sunt reflectate și în afara funcției |
| Argumentele reale și formale vor fi create la locație de memorie diferită | Argumentele reale și formale vor fi create la aceeași locație de memorie. |
Puncte de reținut despre funcțiile din C++
1. Majoritatea programelor C++ au o funcție numită main() care este apelată de sistemul de operare atunci când un utilizator rulează programul.
2. Fiecare funcție are un tip de returnare. Dacă o funcție nu returnează nicio valoare, atunci void este folosit ca tip de returnare. Mai mult decât atât, dacă tipul de returnare al funcției este nul, încă putem folosi instrucțiunea return în corpul definiției funcției fără a specifica nicio constantă, variabilă etc., menționând doar instrucțiunea „return;” simbolizează terminarea funcției după cum se arată mai jos:
C++
void> function name(>int> a)> {> >.......>// Function Body> >return>;>// Function execution would get terminated> }> |
>
>
3. Pentru a declara o funcție care poate fi apelată doar fără niciun parametru, ar trebui să folosim distracție gol (gol) . Ca o notă secundară, în C++, o listă goală înseamnă că o funcție poate fi apelată doar fără niciun parametru. În C++, atât void fun() cât și void fun(void) sunt aceleași.
Functie principala
Funcția principală este o funcție specială. Fiecare program C++ trebuie să conțină o funcție numită main. Acesta servește drept punct de intrare pentru program. Computerul va începe să ruleze codul de la începutul funcției principale.
Tipuri de funcții principale
1. Fara parametri:
CPP
// Without Parameters> int> main() { ...>return> 0; }> |
>
>
2. Cu parametri:
CPP
// With Parameters> int> main(>int> argc,>char>*>const> argv[]) { ...>return> 0; }> |
câți ani are Pete Davidson
>
>
Motivul pentru a avea opțiunea de parametri pentru funcția principală este acela de a permite intrarea din linia de comandă. Când utilizați funcția principală cu parametri, aceasta salvează fiecare grup de caractere (separate printr-un spațiu) după numele programului ca elemente într-o matrice numită argv .
Deoarece funcția principală are tipul return de int , programatorul trebuie să aibă întotdeauna o instrucțiune return în cod. Numărul care este returnat este folosit pentru a informa programul apelant care a fost rezultatul execuției programului. Returnarea 0 semnalează că nu au fost probleme.
Recursiune C++
Când funcția este apelată în cadrul aceleiași funcții, este cunoscută ca recursivitate în C++. Funcția care apelează aceeași funcție este cunoscută sub numele de funcție recursivă.
O funcție care se autoapelează și nu efectuează nicio sarcină după apelul funcției este cunoscută sub numele de recursivitate coadă. În recursiunea coadă, în general numim aceeași funcție cu instrucțiunea return.
Sintaxă:
C++
recursionfunction()> {> >recursionfunction();>// calling self function> }> |
>
>
Pentru a afla mai multe vezi Acest articol .
C++ care trece matrice la funcție
În C++, pentru a reutiliza logica matricei, putem crea o funcție. Pentru a transmite o matrice unei funcții în C++, trebuie să furnizăm doar numele matricei.
function_name(array_name[]); //passing array to function>
Exemplu: Imprimați numărul minim din matricea dată.
C++
#include> using> namespace> std;> void> printMin(>int> arr[5]);> int> main()> {> >int> ar[5] = { 30, 10, 20, 40, 50 };> >printMin(ar);>// passing array to function> }> void> printMin(>int> arr[5])> {> >int> min = arr[0];> >for> (>int> i = 0; i <5; i++) {> >if> (min>arr[i]) {> >min = arr[i];> >}> >}> >cout <<>'Minimum element is: '> << min <<>'
'>;> }> // Code submitted by Susobhan Akhuli> |
>
>Ieșire
Minimum element is: 10>
Complexitatea timpului: O(n) unde n este dimensiunea matricei
Complexitatea spațiului: O(n) unde n este dimensiunea matricei.
Supraîncărcare C++ (funcție)
Dacă creăm doi sau mai mulți membri având același nume, dar diferiți ca număr sau tip de parametri, se numește supraîncărcare C++. În C++, putem supraîncărca:
- metode,
- constructorii si
- proprietăți indexate
Tipurile de supraîncărcare în C++ sunt:
- Supraîncărcarea funcției
- Supraîncărcarea operatorului
Supraîncărcarea funcției C++
Supraîncărcarea funcției este definită ca procesul de a avea două sau mai multe funcții cu același nume, dar cu parametri diferiți. În supraîncărcarea funcției, funcția este redefinită folosind fie diferite tipuri, fie un număr de argumente. Doar prin aceste diferențe un compilator poate diferenția între funcții.
Avantajul supraîncărcării funcțiilor este că crește lizibilitatea programului, deoarece nu trebuie să utilizați nume diferite pentru aceeași acțiune.
Exemplu: modificarea numărului de argumente ale metodei add().
C++
// program of function overloading when number of arguments> // vary> #include> using> namespace> std;> class> Cal {> public>:> >static> int> add(>int> a,>int> b) {>return> a + b; }> >static> int> add(>int> a,>int> b,>int> c)> >{> >return> a + b + c;> >}> };> int> main(>void>)> {> >Cal C;>// class object declaration.> >cout << C.add(10, 20) << endl;> >cout << C.add(12, 20, 23);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Ieșire
30 55>
Complexitatea timpului: O(1)
Complexitatea spațiului: O(1)
Exemplu: când tipul argumentelor variază.
C++
// Program of function overloading with different types of> // arguments.> #include> using> namespace> std;> int> mul(>int>,>int>);> float> mul(>float>,>int>);> int> mul(>int> a,>int> b) {>return> a * b; }> float> mul(>double> x,>int> y) {>return> x * y; }> int> main()> {> >int> r1 = mul(6, 7);> >float> r2 = mul(0.2, 3);> >cout <<>'r1 is : '> << r1 << endl;> >cout <<>'r2 is : '> << r2 << endl;> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>Ieșire
r1 is : 42 r2 is : 0.6>
Complexitatea timpului: O(1)
Complexitatea spațiului: O(1)
Supraîncărcarea funcției și ambiguitatea
Când compilatorul nu poate decide ce funcție va fi invocată printre funcțiile supraîncărcate, această situație este cunoscută ca funcția supraîncărcarea ambiguității.
Când compilatorul arată eroarea de ambiguitate, compilatorul nu rulează programul.
Cauzele ambiguității:
- Conversie tip.
- Funcție cu argumente implicite.
- Funcție cu trecere prin referință.
Conversie tip:-
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>float>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>float> j)> {> >cout <<>'Value of j is : '> << j << endl;> }> int> main()> {> >fun(12);> >fun(1.2);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Exemplul de mai sus arată o eroare apelul „distracției (duble)” supraîncărcate este ambiguu . Fun(10) va apela prima funcție. Fun (1.2) apelează a doua funcție conform predicției noastre. Dar, aceasta nu se referă la nicio funcție ca în C++, toate constantele în virgulă mobilă sunt tratate ca duble, nu ca un float. Dacă înlocuim float cu dublu, programul funcționează. Prin urmare, aceasta este o conversie de tip de la float la dublu.
Funcție cu argumente implicite: -
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>,>int>);> void> fun(>int> i) { cout <<>'Value of i is : '> << i << endl; }> void> fun(>int> a,>int> b = 9)> {> >cout <<>'Value of a is : '> << a << endl;> >cout <<>'Value of b is : '> << b << endl;> }> int> main()> {> >fun(12);> >return> 0;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Exemplul de mai sus arată o eroare apelul „fun(int)” supraîncărcat este ambiguu . Fun(int a, int b=9) poate fi apelat în două moduri: mai întâi este apelând funcția cu un singur argument, adică fun(12) și o altă modalitate este apelarea funcției cu două argumente, adică fun(4). ,5). Funcția fun(int i) este invocată cu un singur argument. Prin urmare, compilatorul nu a putut alege între fun(int i) și fun(int a,int b=9).
Funcție cu referință de trecere: -
C++
#include> using> namespace> std;> void> fun(>int>);> void> fun(>int>&);> int> main()> {> >int> a = 10;> >fun(a);>// error, which fun()?> >return> 0;> }> void> fun(>int> x) { cout <<>'Value of x is : '> << x << endl; }> void> fun(>int>& b)> {> >cout <<>'Value of b is : '> << b << endl;> }> // Code Submitted By Susobhan Akhuli> |
>
>
Exemplul de mai sus arată o eroare apelul „fun(int&)” supraîncărcat este ambiguu . Prima funcție ia un argument întreg, iar a doua funcție ia un parametru de referință ca argument. În acest caz, compilatorul nu știe ce funcție este necesară utilizatorului, deoarece nu există nicio diferență sintactică între fun(int) și fun(int &).
Funcția de prieten
- O funcție prieten este o funcție specială în C++ care, în ciuda faptului că nu este o funcție membră a unei clase, are privilegiul de a accesa datele private și protejate ale unei clase.
- O funcție prieten este o funcție non-membră sau o funcție obișnuită a unei clase, care este declarată prin utilizarea cuvântului cheie prieten în interiorul clasei. Prin declararea unei funcții ca prieten, toate permisiunile de acces sunt acordate funcției.
- Cuvântul cheie prieten este plasat numai în declarația funcției, dar nu și în definiția funcției.
- Când funcția prieten este numită, nu se utilizează nici numele obiectului, nici operatorul punct. Cu toate acestea, poate accepta obiectul ca argument a cărui valoare dorește să o acceseze.
- O funcție prieten poate fi declarată în orice secțiune a clasei, adică publică, privată sau protejată.
Declararea funcției prieten în C++
Sintaxă:
class { friend (argument/s); };> Exemplu_1: Găsiți cel mai mare dintre două numere folosind funcția Friend
C++
#include> using> namespace> std;> class> Largest {> >int> a, b, m;> public>:> >void> set_data();> >friend> void> find_max(Largest);> };> void> Largest::set_data()> {> >cout <<>'Enter the first number : '>;> >cin>> a;> >cout <<>'
Enter the second number : '>;> >cin>> b;> }> void> find_max(Largest t)> {> >if> (t.a>t.b)> >t.m = t.a;> >else> >t.m = t.b;> >cout <<>'
Largest number is '> << t.m;> }> int> main()> {> >Largest l;> >l.set_data();> >find_max(l);> >return> 0;> }> |
>
>
Ieșire
Enter the first number : 789 Enter the second number : 982 Largest number is 982>