Menu

Funktioner i C ++ med typer og eksempler

functions c with types examples

Typer af funktioner i C ++ sammen med deres anvendelser.

I vores tidligere tutorials indtil nu har vi set de forskellige koncepter i C ++ som variabler, lagringsklasser, operatorer, arrays, strenge osv.

I denne vejledning går vi videre og diskuterer begrebet funktioner. Funktioner kaldes også metoder, underrutiner eller procedurer.

konvertere char til int c ++

=> Læs gennem den omfattende C ++ træningsvejledningsserie her.

FUNKTIONER I C ++

Hvad du lærer:

Hvordan definerer vi en funktion?

En funktion er et sæt udsagn, der er sammensat til at udføre en bestemt opgave. Det kan være udsagn, der udfører nogle gentagne opgaver eller udsagn, der udfører nogle specialopgaver som udskrivning osv.

En brug af at have funktioner er at forenkle koden ved at bryde den i mindre enheder kaldet funktioner. Endnu en idé bag brugen af ​​funktioner er, at det sparer os for at skrive den samme kode igen og igen. Vi skal bare skrive en funktion og derefter kalde den efter behov uden at skulle skrive det samme sæt udsagn igen og igen.

Typer af funktioner i C ++

I C ++ har vi to typer funktioner som vist nedenfor.

Typer af funktioner i C ++

Indbyggede funktioner

Indbyggede funktioner kaldes også biblioteksfunktioner. Dette er de funktioner, der leveres af C ++, og vi behøver ikke skrive dem selv. Vi kan bruge disse funktioner direkte i vores kode.

Disse funktioner placeres i headerfiler på C ++. For eksempel , er de overskrifter, der har henholdsvis indbyggede matematiske funktioner og strengfunktioner.

Lad os se et eksempel på brug af indbyggede funktioner i et 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:

Indtast inputstrengen: Software Testing Help
Streng indtastet: Software Testing Help!
Størrelse på streng: 21

Her bruger vi overskrifterne og. Datatyperne og andre input / output-funktioner er defineret i biblioteket. Stringfunktioner, der bruges som getline, størrelse er en del af overskriften.

Brugerdefinerede funktioner

C ++ tillader også sine brugere at definere deres egne funktioner. Dette er de brugerdefinerede funktioner. Vi kan definere funktionerne hvor som helst i programmet og derefter kalde disse funktioner fra en hvilken som helst del af koden. Ligesom variabler skal det erklæres inden brug, funktioner skal også deklareres, før de kaldes.

Lad os diskutere brugerdefinerede funktioner i detaljer.

Den generelle syntaks for brugerdefinerede funktioner (eller simpelthen funktioner) er som angivet nedenfor:

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

Så som vist ovenfor har hver funktion:

  • Returtype: Det er værdien, at funktionerne vender tilbage til opkaldsfunktionen efter at have udført en bestemt opgave.
  • funktionsnavn : Identifikator, der bruges til at navngive en funktion.
  • Parameterliste: Betegnet med param1, param2, ... paramn i ovenstående syntaks. Dette er de argumenter, der overføres til funktionen, når der foretages et funktionsopkald. Parameterlisten er valgfri, dvs. vi kan have funktioner, der ikke har nogen parametre.
  • Funktion krop: En gruppe udsagn, der udfører en bestemt opgave.

Som allerede nævnt er vi nødt til at 'erklære' en funktion, før vi bruger den.

Funktionserklæring

En funktionserklæring fortæller kompilatoren om funktionstypen for returnering, antallet af parametre, der bruges af funktionen og dens datatyper. Inkluderende navnene på parametrene i funktionen er erklæringen valgfri. Funktionserklæringen kaldes også som en funktionsprototype.

Vi har givet nogle eksempler på nedenstående funktionserklæring til din reference.

int sum(int, int);

Ovenstående erklæring er af en funktion 'sum', der tager to heltal som parametre og returnerer en heltalværdi.

void swap(int, int);

Dette betyder, at swap-funktionen tager to parametre af typen int og ikke returnerer nogen værdi, og derfor er returtypen ugyldig.

void display();

Funktionsdisplayet tager ingen parametre og returnerer heller ikke nogen type.

Funktionsdefinition

En funktionsdefinition indeholder alt, hvad en funktionserklæring indeholder, og derudover indeholder den også brødteksten for funktionen, der er omsluttet af parenteser ({}).

Derudover skulle den også have navngivne parametre. Når funktionen kaldes, overføres kontrol af programmet til funktionsdefinitionen, så funktionskoden kan udføres. Når udførelsen af ​​funktionen er afsluttet, går kontrollen tilbage til det punkt, hvor funktionen blev kaldt.

For ovenstående erklæring om swap-funktion er definitionen som angivet nedenfor:

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

Bemærk, at erklæring og definition af en funktion kan gå sammen. Hvis vi definerer en funktion, før vi henviser til den, er der ikke behov for en separat erklæring.

Lad os tage et komplet programmeringseksempel for at demonstrere 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 = '< Opkald til en funktion

Når vi har en funktion i vores program, skal vi, afhængigt af kravet, ringe til eller påkalde denne funktion. Først når funktionen kaldes eller påberåbes, udfører funktionen sit sæt sætninger for at give de ønskede resultater.

Funktionen kan kaldes fra hvor som helst i programmet. Det kan kaldes fra hovedfunktionen eller fra enhver anden funktion, hvis programmet bruger mere end en funktion. Funktionen, der kalder en anden funktion kaldes “Opkaldsfunktion”.

I ovenstående eksempel på swapping-numre kaldes swap-funktionen i hovedfunktionen. Derfor bliver hovedfunktionen den kaldende funktion.

Formelle og faktiske parametre

Vi har allerede set, at vi kan have parametre for funktionerne. Funktionsparametrene findes i funktionsdefinitionen som en parameterliste, der følger funktionsnavnet. Når funktionen kaldes, skal vi videregive de faktiske værdier af disse parametre, så funktionen ved hjælp af disse faktiske værdier kan udføre sin opgave.

De parametre, der er defineret i funktionsdefinitionen kaldes Formelle parametre . Parameterne i funktionsopkaldet, der er de faktiske værdier, kaldes Faktiske parametre.

I ovenstående eksempel på byttetal har vi skrevet kommentarerne til formelle og faktiske parametre. I opkaldsfunktionen, dvs. hoved, læses værdien af ​​to heltal og overføres til swap-funktionen. Dette er de faktiske parametre.

Vi kan se definitionerne af disse parametre i første linje i funktionsdefinitionen. Dette er de formelle parametre.

Bemærk, at typen af ​​formelle og faktiske argumenter skal matche. Rækkefølgen af ​​formelle og faktiske parametre skal også matche.

Returneringsværdier

Når funktionen udfører den tilsigtede opgave, skal den returnere resultatet til opkaldsfunktionen. Til dette har vi brug for returneringstypen for funktionen. Funktionen kan returnere en enkelt værdi til opkaldsfunktionen. Funktionens returtype erklæres sammen med funktionsprototypen.

Lad os tage et eksempel på at tilføje to tal for at demonstrere returtyperne.

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

Indtast de to tal, der skal tilføjes: 11 11

Summen af ​​de to tal: 22

I ovenstående eksempel har vi en funktionssum, der tager to heltalsparametre og returnerer en heltalstype. I hovedfunktionen læser vi to heltal fra konsolindgangen og sender den til sumfunktionen. Da returtypen er et heltal, har vi en resultatvariabel på LHS, og RHS er et funktionsopkald.

Når en funktion udføres, tildeles udtrykket (a + b), der returneres af funktionssummen, til resultatvariablen. Dette viser, hvordan funktionens returværdi bruges.

Ugyldige funktioner

Vi har set, at den generelle syntaks for funktion kræver, at der defineres en returtype. Men hvis vi har en sådan funktion, der ikke returnerer nogen værdi, i så fald, hvad specificerer vi som returtype? Svaret er, at vi bruger værdiløs type 'ugyldig' for at indikere, at funktionen ikke returnerer en værdi.

I et sådant tilfælde kaldes funktionen 'ugyldig funktion', og dens prototype vil være som

ugyldigt funktionsnavn (param1, param2,… .param 3);

Bemærk : Det betragtes som en god praksis at medtage en erklæring 'retur'. i slutningen af ​​tomrumsfunktionen for klarhed.

Videregivelse af parametre til funktioner

Vi har allerede set begrebet faktiske og formelle parametre. Vi ved også, at faktiske parametre overfører værdier til en funktion, der modtages af formatparametrene. Dette kaldes videregivelse af parametre.

I C ++ har vi visse måder at overføre parametre som beskrevet nedenfor.

Gå forbi værdi

I programmet til at bytte to heltal, som vi diskuterede tidligere, har vi set, at vi bare læste heltal 'a' og 'b' i hovedtræk og overførte dem til swap-funktionen. Dette er forbipasserings-teknikken.

I forbipasseringsværditeknikken til parameteroverføring videregives kopierne af værdier af faktiske parametre til de formelle parametre. På grund af dette lagres de faktiske og formelle parametre på forskellige hukommelsessteder. Ændringer foretaget i formelle parametre inde i funktionen afspejles således ikke uden for funktionen.

Vi kan forstå dette bedre ved igen at besøge bytte af to tal.

#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å forbi reference

Pass by reference er endnu en teknik, der bruges af C ++ til at overføre parametre til funktioner. I stedet for at sende kopier af faktiske parametre videregiver vi henvisninger til faktiske parametre i denne teknik.

Bemærk: Referencer er intet andet end aliaser for variabler eller i enkle ord, det er et andet navn, der gives til en variabel. Derfor har en variabel og dens reference samme hukommelsesplacering. Vi lærer referencer i detaljer i vores efterfølgende tutorial.

I forbipasserende referenceteknik bruger vi disse referencer til faktiske parametre, og som et resultat reflekteres ændringerne foretaget i formelle parametre i funktionen tilbage til den kaldende funktion.

Vi ændrer vores swap-funktion, så vores læsere kan forstå konceptet bedre.

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

Derfor ændres de formelle parametre i swap-funktionen i hovedfunktionen, og vi får de byttede værdier.

Gå forbi markøren

I C ++ kan vi også videregive parametre til at fungere ved hjælp af markørvariabler. Pass by pointer-teknikken producerer de samme resultater som ved at passere som reference. Dette betyder, at både formelle og faktiske parametre deler de samme hukommelsesplaceringer, og ændringerne i funktion afspejles i opkaldsfunktionen.

Den eneste forskel, at vi i en forbipasseringsreference beskæftiger os med referencer eller aliaser for parametre, mens vi i en forbipasserende teknik bruger markørvariabler til at videregive parametrene.

Markørvariabler adskiller sig med de referencer, hvor markørvariabler peger på en bestemt variabel, og i modsætning til referencer kan vi ændre den variabel, som den peger på. Vi udforsker detaljerne i markøren i vores efterfølgende tutorials.

Vi præsenterer byttet af to heltal igen for at demonstrere teknikken 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 = '< Standardparametre

I C ++ kan vi give standardværdier for funktionsparametre. I dette tilfælde angiver vi ikke parametre, når vi påkalder funktionen. I stedet tager funktionen de standardparametre, der er angivet i prototypen.

Følgende eksempel viser brugen af ​​standardparametre.

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

Indtast værdier for a, b og c: 10 4 6

Opfordring til matematik med 1 arg: 15
Opfordring til matematik med 2 arg: 20
Opfordring til matematik med 3 arg: 6

Som vist i kodeeksemplet har vi en funktion 'mathoperation', der tager tre parametre, hvorfra vi har angivet standardværdier for to parametre. Så i hovedfunktionen kalder vi denne funktion tre gange med en anden argumenteliste.

Det første opkald er kun med et argument. I dette tilfælde har de to andre argumenter standardværdier. Det næste opkald er med to argumenter. I dette tilfælde har det tredje argument en standardværdi. Det tredje opkald er med tre argumenter. I dette tilfælde ignoreres standardværdierne, da vi har angivet alle de tre argumenter.

Bemærk, at mens vi leverer standardparametre, starter vi altid fra parameteren til højre. Vi kan heller ikke springe over en parameter imellem og angive en standardværdi for den næste parameter.

Lad os nu gå videre til et par specielle funktionsrelaterede begreber, der er vigtige set fra en programmørs synspunkt.

Const-parametre

Vi kan også videregive konstante parametre til funktioner ved hjælp af 'const' nøgleordet. Når en parameter eller reference er const, kan den ikke ændres inde i funktionen.

Bemærk, at vi ikke kan overføre en const-parameter til en ikke-const-formel parameter. Men vi kan overføre const og non-const parameter til en const formel parameter.

På samme måde kan vi også have const return-type. I dette tilfælde kan returtypen heller ikke ændres.

Lad os se et kodeeksempel, der bruger const-referencer.

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

Indtast de to tal, der skal byttes: 22 33
a = 2 b = 33
Resultat af tilføjelse: 55

I ovenstående program har vi const formelle parametre. Bemærk, at de faktiske parametre er almindelige ikke-const-variabler, som vi har bestået. Da formelle parametre er const, kan vi ikke ændre dem inde i funktionen. Så vi udfører bare tilføjelsesoperationen og returnerer værdien.

Hvis vi forsøger at ændre værdierne for a eller b inde i funktionen, udstiller compileren en fejl.

Inline-funktioner

Vi ved, at for at foretage et funktionsopkald involverer det internt en kompilator, der lagrer programmets tilstand på en stak, før den overfører kontrol til funktionen.

Når funktionen vender tilbage, skal compileren hente programtilstanden tilbage og fortsætte fra det sted, hvor den gik. Dette udgør en overhead. Derfor er der i C ++ hver gang vi har en funktion, der består af få udsagn, en facilitet, der gør det muligt at udvide inline. Dette gøres ved at lave en funktion inline.

Så inline-funktioner er de funktioner, der udvides ved kørsel, hvilket sparer bestræbelserne på at ringe til funktionen og foretage stakændringer. Men selvom vi laver en funktion som inline, garanterer ikke compileren, at den udvides ved kørsel. Med andre ord er det helt afhængigt af kompilatoren at gøre funktionen integreret eller ej.

Nogle compilere registrerer mindre funktioner og udvider dem inline, selvom de ikke er erklæret inline.

Følgende er et eksempel på en integreret funktion.

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

Som vist ovenfor går vi forud for funktionsdefinitionen med et nøgleord 'inline' for at gøre en funktion inline.

Brug af strukturer i funktioner

Vi kan overføre strukturvariabler som parametre for at fungere på en lignende måde, hvor vi overfører almindelige variabler som parametre.

Dette er vist i det følgende eksempel.

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

Indtast navn: Vedang
Indtast alder: 22
Indtast løn: 45000,00
PersonInfo struktur:
Alder: 22
Navn: Vedang
Løn: 45000

Brug af strukturer i funktioner - Output

Som vist i ovenstående program passerer vi en struktur til at fungere på samme måde som andre variabler. Vi læser værdier for strukturelementer fra standardindgangen og sender derefter en struktur til en funktion, der viser strukturen.

Konklusion

Dette handlede om de grundlæggende funktioner i C ++.

Vi vil udforske mere om de statiske funktioner i C ++ i vores kommende tutorials.

=> Tjek Komplet C ++ GRATIS træningsserie her.

Anbefalet læsning

^