Meny

Funktioner i C ++ med typer och exempel

functions c with types examples

Prova Vårt Instrument För Att Eliminera Problem

Typer av funktioner i C ++ tillsammans med deras användning.

I våra tidigare tutorials hittills har vi sett de olika begreppen i C ++ som variabler, lagringsklasser, operatorer, arrays, strängar etc.

I denna handledning kommer vi att gå vidare och diskutera begreppet funktioner. Funktioner kallas också metoder, underrutiner eller procedurer.

=> Läs igenom den omfattande C ++ - utbildningsserien här.

FUNKTIONER I C ++

Vad du kommer att lära dig:

Hur definierar vi en funktion?

En funktion är en uppsättning uttalanden som är sammanställda för att utföra en specifik uppgift. Det kan vara uttalanden som utför vissa upprepade uppgifter eller uttalanden som utför vissa specialuppgifter som utskrift etc.

En användning av att ha funktioner är att förenkla koden genom att bryta den i mindre enheter som kallas funktioner. Ännu en idé bakom användning av funktioner är att det sparar oss från att skriva samma kod om och om igen. Vi måste bara skriva en funktion och sedan kalla den när det behövs utan att behöva skriva samma uppsättning påståenden om och om igen.

Typer av funktioner i C ++

I C ++ har vi två typer av funktioner som visas nedan.

Typer av funktioner i C ++

Inbyggda funktioner

Inbyggda funktioner kallas också biblioteksfunktioner. Det här är de funktioner som tillhandahålls av C ++ och vi behöver inte skriva dem själva. Vi kan direkt använda dessa funktioner i vår kod.

Dessa funktioner placeras i huvudfilerna på C ++. Till exempel ,, är rubrikerna som har inbyggda matematiska funktioner respektive strängfunktioner.

Låt oss se ett exempel på hur du använder inbyggda funktioner i ett 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 : '<

Produktion:

Ange inmatningssträngen: Software Testing Help
Inmatad sträng: Software Testing Help!
Strängens storlek: 21

Här använder vi rubrikerna och. Datatyperna och andra in- / utgångsfunktioner definieras i biblioteket. Strängfunktioner som används som getline, storlek är en del av rubriken.

Användardefinierade funktioner

C ++ tillåter dess användare att definiera sina egna funktioner. Dessa är de användardefinierade funktionerna. Vi kan definiera funktionerna var som helst i programmet och sedan anropa dessa funktioner från valfri del av koden. Precis som variabler bör det deklareras innan användning, funktioner måste också deklareras innan de anropas.

Låt oss diskutera användardefinierade funktioner i detalj.

Den allmänna syntaxen för användardefinierade funktioner (eller helt enkelt funktioner) är enligt nedan:

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

Så som visas ovan har varje funktion:

  • Returtyp: Det är värdet som funktionerna återgår till den anropande funktionen efter att ha utfört en specifik uppgift.
  • funktionsnamn : Identifierare som används för att namnge en funktion.
  • Parameterlista: Betecknas med param1, param2, ... paramn i ovanstående syntax. Det här är argumenten som skickas till funktionen när ett funktionsanrop görs. Parameterlistan är valfri, dvs. vi kan ha funktioner som inte har några parametrar.
  • Funktion kropp: En grupp uttalanden som utför en specifik uppgift.

Som redan nämnts måste vi ”deklarera” en funktion innan vi använder den.

Funktionsdeklaration

En funktionsdeklaration berättar kompilatorn om funktionens returtyp, antalet parametrar som används av funktionen och dess datatyper. Inkluderande namnen på parametrarna i funktionen är deklarationen valfri. Funktionsdeklarationen kallas också som en funktionsprototyp.

Vi har gett några exempel på funktionsdeklarationen nedan för din referens.

int sum(int, int);

Ovanstående deklaration har en funktion ”summa” som tar två heltal som parametrar och returnerar ett heltalvärde.

void swap(int, int);

Detta innebär att swapfunktionen tar två parametrar av typen int och inte returnerar något värde och därför är returtypen ogiltig.

void display();

Funktionsdisplayen tar inga parametrar och returnerar inte heller någon typ.

Funktionsdefinition

En funktionsdefinition innehåller allt som en funktionsdeklaration innehåller och dessutom innehåller den även huvuddelen av funktionen som är innesluten i hakparenteser ({}).

Dessutom borde det också ha namngivna parametrar. När funktionen anropas övergår kontrollen av programmet till funktionsdefinitionen så att funktionskoden kan köras. När körningen av funktionen är klar, går kontrollen tillbaka till den punkt där funktionen anropades.

För ovanstående deklaration av bytesfunktion är definitionen enligt nedan:

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

Observera att deklaration och definition av en funktion kan gå ihop. Om vi ​​definierar en funktion innan vi refererar till det finns inget behov av en separat deklaration.

Låt oss ta ett fullständigt programmeringsexempel för att demonstrera en funktion.

#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 = '< Ringa till en funktion

När vi har en funktion i vårt program behöver vi, beroende på kravet, ringa eller åberopa den här funktionen. Endast när funktionen anropas eller åberopas, utför funktionen sin uppsättning uttalanden för att ge önskat resultat.

Funktionen kan anropas var som helst i programmet. Det kan anropas från huvudfunktionen eller från någon annan funktion om programmet använder mer än en funktion. Funktionen som anropar en annan funktion kallas ”Calling-funktionen”.

I ovanstående exempel på swapping-nummer kallas swap-funktionen i huvudfunktionen. Därför blir huvudfunktionen den anropande funktionen.

Formella och faktiska parametrar

Vi har redan sett att vi kan ha parametrar för funktionerna. Funktionsparametrarna finns i funktionsdefinitionen som en parameterlista som följer funktionsnamnet. När funktionen anropas måste vi skicka de faktiska värdena för dessa parametrar så att med hjälp av dessa faktiska värden kan funktionen utföra sin uppgift.

Parametrarna som definieras i funktionsdefinitionen anropas Formella parametrar . Parametrarna i funktionsanropet som är de faktiska värdena anropas Faktiska parametrar.

I ovanstående exempel på byte av nummer har vi skrivit kommentarerna för formella och faktiska parametrar. I anropsfunktionen, dvs. huvud, läses värdet av två heltal och skickas till bytesfunktionen. Dessa är de faktiska parametrarna.

Vi kan se definitionerna av dessa parametrar i den första raden i funktionsdefinitionen. Dessa är de formella parametrarna.

Observera att typen av formella och faktiska argument ska matcha. Ordningen på formella och faktiska parametrar bör också matcha.

Returvärden

När funktionen har utfört sin avsedda uppgift bör den returnera resultatet till den anropande funktionen. För detta behöver vi funktionens returtyp. Funktionen kan returnera ett enda värde till den anropande funktionen. Funktionens returtyp deklareras tillsammans med funktionsprototypen.

Låt oss ta ett exempel på att lägga till två nummer för att visa returtyperna.

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

Produktion:

Ange de två siffrorna som ska läggas till: 11 11

Summan av de två siffrorna: 22

I exemplet ovan har vi en funktionssumma som tar två heltalsparametrar och returnerar en heltalstyp. I huvudfunktionen läser vi två heltal från konsolingången och skickar den till sumfunktionen. Eftersom returtypen är ett heltal har vi en resultatvariabel på LHS och RHS är ett funktionsanrop.

När en funktion utförs tilldelas resultatvariabeln uttrycket (a + b) som returneras av funktionssumman. Detta visar hur returvärdet för funktionen används.

Ogiltiga funktioner

Vi har sett att den allmänna syntaxen för funktionen kräver att en returtyp definieras. Men om vi har en sådan funktion som inte returnerar något värde, i vilket fall, vad anger vi som returtyp? Svaret är att vi använder värdelös typ ”tom” för att indikera att funktionen inte returnerar ett värde.

I ett sådant fall kallas funktionen ”tomrumsfunktion” och dess prototyp kommer att vara som

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

Notera : Det betraktas som en god praxis att inkludera ett uttalande ”returnera”. i slutet av tomrumsfunktionen för tydlighet.

Skicka parametrar till funktioner

Vi har redan sett begreppet faktiska och formella parametrar. Vi vet också att faktiska parametrar skickar värden till en funktion som tas emot av formatparametrarna. Detta kallas överföring av parametrar.

I C ++ har vi vissa sätt att skicka parametrar som diskuteras nedan.

Gå förbi värde

I programmet för att byta två heltal som vi diskuterade tidigare har vi sett att vi bara läser heltal 'a' och 'b' i huvudsak och skickade dem till swap-funktionen. Detta är pass by value-tekniken.

I förbikopplingsvärde-tekniken för parameteröverföring skickas kopiorna av värdena för faktiska parametrar till de formella parametrarna. På grund av detta lagras de faktiska och formella parametrarna på olika minnesplatser. Ändringar som gjorts i formella parametrar inuti funktionen återspeglar således inte utanför funktionen.

Vi kan förstå detta bättre genom att återigen besöka bytet av två nummer.

#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 = '< Gå förbi referens

Pass by reference är ännu en teknik som används av C ++ för att skicka parametrar till funktioner. I den här tekniken skickar vi referenser till faktiska parametrar istället för att skicka kopior av faktiska parametrar.

Notera: Referenser är inget annat än alias för variabler eller med enkla ord, det är ett annat namn som ges till en variabel. Därför delar en variabel och dess referens samma minnesplats. Vi kommer att lära oss referenser i detalj i vår efterföljande handledning.

I förbigående referensteknik använder vi dessa referenser av faktiska parametrar och som ett resultat reflekteras ändringarna av formella parametrar i funktionen tillbaka till den anropande funktionen.

Vi ändrar vår swap-funktion så att våra läsare förstår konceptet bättre.

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

Därför speglas de ändringar som gjorts i de formella parametrarna i swap-funktionen i huvudfunktionen och vi får de bytte värdena.

Passera pekaren

I C ++ kan vi också skicka parametrar för att fungera med pekvariabler. Pass by-pekare-tekniken ger samma resultat som att passera genom referens. Detta innebär att både formella och faktiska parametrar delar samma minnesplatser och ändringarna i funktionen återspeglas i den anropande funktionen.

Den enda skillnaden att vi i en passera-referens hanterar referenser eller alias för parametrar medan vi i en pass-by-pekarteknik använder pekervariabler för att skicka parametrarna.

Pekervariabler skiljer sig från referenserna där pekvariablerna pekar på en viss variabel och till skillnad från referenser kan vi ändra variabeln som den pekar på. Vi kommer att utforska detaljerna i pekaren i våra efterföljande handledning.

Vi presenterar bytet av två heltal igen för att demonstrera tekniken 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 = '< Standardparametrar

I C ++ kan vi tillhandahålla standardvärden för funktionsparametrar. I det här fallet, när vi åberopar funktionen, anger vi inte parametrar. Istället tar funktionen standardparametrarna som finns i prototypen.

Följande exempel visar användningen av standardparametrar.

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

Produktion:

Ange värden för a, b och c: 10 4 6

Call to mathoperation med 1 arg: 15
Call to mathoperation med 2 arg: 20
Call to mathoperation med 3 arg: 6

Som visas i kodexemplet har vi en funktion ”mathoperation” som tar tre parametrar varav vi har angett standardvärden för två parametrar. Sedan i huvudfunktionen kallar vi den här funktionen tre gånger med en annan argumentlista.

Det första samtalet är bara med ett argument. I det här fallet har de andra två argumenten standardvärden. Nästa samtal är med två argument. I det här fallet kommer det tredje argumentet att ha ett standardvärde. Det tredje samtalet är med tre argument. I det här fallet ignoreras standardvärden eftersom vi har tillhandahållit alla de tre argumenten.

Observera att medan vi tillhandahåller standardparametrar, börjar vi alltid från den högsta parametern. Vi kan inte heller hoppa över en parameter däremellan och tillhandahålla ett standardvärde för nästa parameter.

Låt oss nu gå vidare till några speciella funktionsrelaterade begrepp som är viktiga ur en programmerares synvinkel.

Const-parametrar

Vi kan också skicka konstanta parametrar till funktioner med hjälp av 'const' nyckelordet. När en parameter eller referens är const kan den inte ändras inuti funktionen.

Observera att vi inte kan skicka en const-parameter till en icke-const formell parameter. Men vi kan överföra parametern const och non-const till en formell parameter const.

På samma sätt kan vi också ha const return-type. I det här fallet kan returtypen inte heller ändras.

Låt oss se ett kodexempel som använder const-referenser.

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

Produktion:

Ange de två siffrorna som ska bytas ut: 22 33
a = 2 b = 33
Resultat av tillägg: 55

I programmet ovan har vi const formella parametrar. Observera att de faktiska parametrarna är vanliga icke-const-variabler som vi har skickat. Eftersom formella parametrar är const kan vi inte ändra dem inuti funktionen. Så vi utför bara tilläggsoperationen och returnerar värdet.

Om vi ​​försöker ändra värdena för a eller b inuti funktionen kommer kompilatorn att ge ett fel.

Inline-funktioner

Vi vet att för att göra ett funktionsanrop, innebär det internt att en kompilator lagrar programmets tillstånd på en stack innan han överför kontrollen till funktionen.

När funktionen återvänder måste kompilatorn hämta tillbaka programtillståndet och fortsätta från den plats där den lämnade. Detta utgör en overhead. Därför finns det i C ++ när vi har en funktion som består av få påståenden, en möjlighet som gör att den kan expandera inline. Detta görs genom att göra en funktion inline.

Så inline-funktioner är de funktioner som utökas vid körning, vilket sparar ansträngningarna att ringa funktionen och göra stackändringarna. Men även om vi gör en funktion som inline, garanterar inte kompilatorn att den kommer att utökas vid körning. Med andra ord är det helt beroende av att kompilatorn gör funktionen inbyggd eller inte.

Vissa kompilatorer upptäcker mindre funktioner och utökar dem inline även om de inte deklareras inline.

Följande är ett exempel på en inline-funktion.

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

Som visas ovan föregår vi funktionsdefinitionen med ett nyckelord 'inline' för att göra en funktion inline.

Använda funktioner i funktioner

Vi kan skicka strukturvariabler som parametrar för att fungera på ett liknande sätt där vi skickar vanliga variabler som parametrar.

Detta visas i följande exempel.

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

Produktion:

Ange namn: Vedang
Ange ålder: 22
Ange lön: 45000,00
PersonInfo-struktur:
Ålder: 22
Namn: Vedang
Lön: 45000

Använda funktioner i funktioner - Output

Som visas i ovanstående program passerar vi en struktur för att fungera på liknande sätt som andra variabler. Vi läser värden för strukturdelar från standardingången och skickar sedan en struktur till en funktion som visar strukturen.

Slutsats

Det här handlade om grunderna för funktioner i C ++.

Vi kommer att utforska mer om de statiska funktionerna i C ++ i våra kommande handledning.

=> Kontrollera Komplett C ++ GRATIS träningsserie här.

Rekommenderad läsning

^