En funktion är en uppsättning satser som tar input, gör någon specifik beräkning, och producerar produktion. Tanken är att sätta några gemensamt eller upprepade gånger gjort uppgifter tillsammans för att göra en fungera så att istället för att skriva samma kod om och om igen för olika ingångar kan vi anropa denna funktion.
Enkelt uttryckt är en funktion ett kodblock som bara körs när den anropas.
Syntax:
Syntax för funktion
Exempel:
C++
fjäderstövelkommentarer
// 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;> }> |
>
>Produktion
m is 20>
Tidskomplexitet: O(1)
Utrymmes komplexitet: O(1)
Varför behöver vi funktioner?
- Funktioner hjälper oss minska kodredundans . Om funktionalitet utförs på flera ställen i programvaran, istället för att skriva samma kod, om och om igen, skapar vi en funktion och kallar den överallt. Detta hjälper också till med underhållet eftersom vi bara måste göra ändringar på ett ställe om vi gör ändringar i funktionaliteten i framtiden.
- Funktioner gör kod modul- . Tänk på en stor fil med många rader kod. Det blir riktigt enkelt att läsa och använda koden, om koden är uppdelad i funktioner.
- Funktioner ger abstraktion . Till exempel kan vi använda biblioteksfunktioner utan att oroa oss för deras interna arbete.
Funktionsdeklaration
En funktionsdeklaration berättar för kompilatorn om antalet parametrar, datatyper av parametrar och returnerar typ av funktion. Att skriva parameternamn i funktionsdeklarationen är valfritt men det är nödvändigt att lägga in dem i definitionen. Nedan finns ett exempel på funktionsdeklarationer. (parameternamn finns inte i nedanstående deklarationer)
Funktionsdeklaration
Exempel:
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>);> |
>
>
Typer av funktioner
Typer av funktioner i C++
Användardefinierad funktion
Användardefinierade funktioner är användar-/kunddefinierade kodblock speciellt anpassade för att minska komplexiteten hos stora program. De är också allmänt kända som skräddarsydda funktioner som endast är byggda för att tillfredsställa det tillstånd där användaren står inför problem samtidigt som det minskar komplexiteten i hela programmet.
Biblioteksfunktion
Biblioteksfunktioner kallas också inbyggda funktioner . Dessa funktioner är en del av ett kompilatorpaket som redan är definierat och består av en speciell funktion med speciella och olika betydelser. Inbyggd funktion ger oss en fördel eftersom vi direkt kan använda dem utan att definiera dem medan vi i den användardefinierade funktionen måste deklarera och definiera en funktion innan vi använder dem.
Till exempel: sqrt(), setw(), strcat(), etc.
Parameterpassering till funktioner
Parametrarna som skickas till funktionen anropas faktiska parametrar . Till exempel, i programmet nedan, är 5 och 10 faktiska parametrar.
Parametrarna som tas emot av funktionen anropas formella parametrar . Till exempel, i programmet ovan är x och y formella parametrar.
Formell parameter och faktisk parameter
Det finns två mest populära sätt att skicka parametrar:
- Pass-by-värde: I denna parameteröverföringsmetod kopieras värden för faktiska parametrar till funktionens formella parametrar. De faktiska och formella parametrarna lagras på olika minnesplatser så att eventuella ändringar som görs i funktionerna inte återspeglas i de faktiska parametrarna för den som ringer.
- Passera referens: Både faktiska och formella parametrar hänvisar till samma platser, så alla ändringar som görs i funktionen återspeglas i de faktiska parametrarna för den som ringer.
Funktionsdefinition
Passera på värde används där värdet på x inte ändras med funktionen 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;> }> |
>
>Produktion
x = 20>
Tidskomplexitet: O(1)
Utrymmes komplexitet: O(1)
Funktioner med hjälp av pekare
Funktionen fun() förväntar sig en pekare ptr till ett heltal (eller en adress till ett heltal). Den ändrar värdet på adressen ptr. Däreferensoperatören * används för att komma åt värdet på en adress. I satsen '*ptr = 30' ändras värdet vid adress ptr till 30. Adressoperatorn & används för att få adressen till en variabel av vilken datatyp som helst. I funktionsanropssatsen 'fun(&x)' skickas adressen till x så att x kan ändras med hjälp av dess adress.
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;> }> |
>
>Produktion
x = 30>
Tidskomplexitet: O(1)
Utrymmes komplexitet: O(1)
Skillnaden mellan call by value och call by reference i C++
| Ring efter värde | Ring genom referens |
|---|---|
| En kopia av värdet skickas till funktionen | En värdeadress skickas till funktionen |
| Ändringar som görs inuti funktionen är det inte reflekteras över andra funktioner | Ändringar som görs i funktionen återspeglas även utanför funktionen |
| Faktiska och formella argument kommer att skapas kl annan minnesplats | Faktiska och formella argument kommer att skapas kl samma minnesplats. |
Punkter att komma ihåg om funktioner i C++
1. De flesta C++-program har en funktion som heter main() som anropas av operativsystemet när en användare kör programmet.
2. Varje funktion har en returtyp. Om en funktion inte returnerar något värde, används void som en returtyp. Dessutom, om returtypen för funktionen är ogiltig, kan vi fortfarande använda retursatsen i funktionsdefinitionens brödtext genom att inte specificera någon konstant, variabel, etc. med den, genom att bara nämna 'return;'-satsen som skulle göra det symboliserar avslutningen av funktionen som visas nedan:
C++
void> function name(>int> a)> {> >.......>// Function Body> >return>;>// Function execution would get terminated> }> |
>
c# handledning
>
3. För att deklarera en funktion som bara kan anropas utan någon parameter bör vi använda void kul (void) . Som en sidoanteckning, i C++ betyder en tom lista att en funktion endast kan anropas utan någon parameter. I C++ är både void fun() och void fun(void) samma.
Huvudfunktion
Huvudfunktionen är en specialfunktion. Varje C++-program måste innehålla en funktion som heter main. Det fungerar som startpunkt för programmet. Datorn kommer att börja köra koden från början av huvudfunktionen.
Typer av huvudfunktioner
1. Utan parametrar:
CPP
// Without Parameters> int> main() { ...>return> 0; }> |
>
>
2. Med parametrar:
CPP
// With Parameters> int> main(>int> argc,>char>*>const> argv[]) { ...>return> 0; }> |
>
>
Anledningen till att ha parameteralternativet för huvudfunktionen är att tillåta inmatning från kommandoraden. När du använder huvudfunktionen med parametrar, sparar den varje grupp av tecken (avgränsade med ett mellanslag) efter programnamnet som element i en array med namnet argv .
Eftersom huvudfunktionen har returtypen int , måste programmeraren alltid ha en retursats i koden. Numret som returneras används för att informera det anropande programmet vad resultatet av programmets körning blev. Att returnera 0 signalerar att det inte var några problem.
C++ Rekursion
När en funktion anropas inom samma funktion kallas den för rekursion i C++. Funktionen som anropar samma funktion kallas rekursiv funktion.
En funktion som anropar sig själv och inte utför någon uppgift efter funktionsanrop kallas svansrekursion. I svansrekursion kallar vi i allmänhet samma funktion med retursats.
Syntax:
C++
recursionfunction()> {> >recursionfunction();>// calling self function> }> |
>
>
För att veta mer se Denna artikel .
C++ skickar array till funktion
I C++, för att återanvända arraylogiken, kan vi skapa en funktion. För att skicka en array till en funktion i C++ behöver vi bara ange arraynamnet.
function_name(array_name[]); //passing array to function>
Exempel: Skriv ut det minsta antalet i den givna arrayen.
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> |
>
>Produktion
Minimum element is: 10>
Tidskomplexitet: O(n) där n är storleken på arrayen
Utrymmes komplexitet: O(n) där n är storleken på arrayen.
C++ överbelastning (funktion)
Om vi skapar två eller flera medlemmar med samma namn men olika i antal eller typ av parametrar, kallas det C++-överbelastning. I C++ kan vi överbelasta:
- metoder,
- konstruktörer och
- indexerade egenskaper
Typer av överbelastning i C++ är:
- Funktionsöverbelastning
- Operatör överbelastning
C++ Funktion Överbelastning
Funktionsöverbelastning definieras som processen att ha två eller flera funktioner med samma namn, men olika parametrar. Vid funktionsöverbelastning omdefinieras funktionen genom att använda antingen olika typer eller antal argument. Det är bara genom dessa skillnader en kompilator kan skilja mellan funktionerna.
Fördelen med funktionsöverbelastning är att det ökar programmets läsbarhet eftersom du inte behöver använda olika namn för samma åtgärd.
Exempel: ändra antalet argument för add()-metoden
C++
Charat i sträng
// 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> |
>
>Produktion
30 55>
Tidskomplexitet: O(1)
Utrymmes komplexitet: O(1)
Exempel: när typen av argument varierar.
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> |
>
>Produktion
r1 is : 42 r2 is : 0.6>
Tidskomplexitet: O(1)
Utrymmes komplexitet: O(1)
Funktion Överbelastning och tvetydighet
När kompilatorn inte kan bestämma vilken funktion som ska anropas bland den överbelastade funktionen är denna situation känd som funktionsöverbelastade tvetydighet.
När kompilatorn visar tvetydighetsfelet kör inte kompilatorn programmet.
Orsaker till tvetydighet:
- Typkonvertering.
- Funktion med standardargument.
- Funktion med pass-by-referens.
Typkonvertering:-
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> |
>
>
Ovanstående exempel visar ett fel anropet av överbelastat 'roligt(dubbel)' är tvetydigt . Fun(10) anropar den första funktionen. Fun(1.2) anropar den andra funktionen enligt vår förutsägelse. Men detta hänvisar inte till någon funktion som i C++, alla flyttalskonstanter behandlas som dubbla inte som en flytande. Om vi byter ut float till dubbel så fungerar programmet. Därför är detta en typomvandling från float till dubbel.
Funktion med standardargument:-
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> |
>
>
Ovanstående exempel visar ett fel anropet av överbelastat 'fun(int)' är tvetydigt . Fun(int a, int b=9) kan anropas på två sätt: det första är genom att anropa funktionen med ett argument, dvs fun(12) och ett annat sätt är att anropa funktionen med två argument, d.v.s. fun(4) ,5). Fun(int i)-funktionen anropas med ett argument. Därför kunde kompilatorn inte välja mellan fun(int i) och fun(int a,int b=9).
Funktion med Pass By Reference:-
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> |
>
>
Ovanstående exempel visar ett fel anropet av överbelastat 'fun(int&)' är tvetydigt . Den första funktionen tar ett heltalsargument och den andra funktionen tar en referensparameter som ett argument. I det här fallet vet inte kompilatorn vilken funktion som behövs av användaren eftersom det inte finns någon syntaktisk skillnad mellan fun(int) och fun(int &).
Vänfunktion
- En vänfunktion är en speciell funktion i C++ som trots att den inte är medlem i en klass har privilegiet att komma åt privata och skyddade data i en klass.
- En vänfunktion är en icke-medlemsfunktion eller en vanlig funktion i en klass, som deklareras genom att använda nyckelordet vän i klassen. Genom att deklarera en funktion som en vän ges alla åtkomstbehörigheter till funktionen.
- Nyckelordet vän placeras endast i funktionsdeklarationen men inte i funktionsdefinitionen.
- När vänfunktionen anropas används varken namnet på objektet eller punktoperatorn. Det kan dock acceptera objektet som ett argument vars värde den vill komma åt.
- En vänfunktion kan deklareras i vilken del av klassen som helst, dvs offentlig, privat eller skyddad.
Vänförklaringsfunktion i C++
Syntax:
class { friend (argument/s); };> Exempel_1: Hitta det största av två tal med hjälp av Friend Function
C++
intilliggande vinklar
#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;> }> |
>
>
Produktion
Enter the first number : 789 Enter the second number : 982 Largest number is 982>