Functies in C-programmering met voorbeelden: recursief, inline

Wat is een functie in C?

Functie in C-programmering is een herbruikbaar codeblok dat een programma gemakkelijker te begrijpen en te testen maakt en gemakkelijk kan worden gewijzigd zonder het aanroepende programma te wijzigen. Functies verdelen de code en modulariseren het programma voor betere en effectieve resultaten. Kortom, een groter programma is onderverdeeld in verschillende subprogramma's die als functies worden genoemd

Wanneer u een groot programma in verschillende functies opsplitst, wordt het gemakkelijk om elke functie afzonderlijk te beheren. Elke keer dat er een fout optreedt in het programma, kunt u eenvoudig defecte functies onderzoeken en alleen die fouten corrigeren. U kunt eenvoudig functies oproepen en gebruiken wanneer ze nodig zijn, wat automatisch leidt tot een besparing van tijd en ruimte.

In deze tutorial leer je-

Bibliotheek Vs. Door de gebruiker gedefinieerde functies
Functie Verklaring
Functie definitie
Functie-oproep
Functieargumenten
Variabele reikwijdte
Statische variabelen
Recursieve functies
Inline-functies

Bibliotheek Vs. Door de gebruiker gedefinieerde functies

Elk 'C'-programma heeft ten minste één functie die de hoofdfunctie is, maar een programma kan een aantal functies hebben. De main () functie in C is een startpunt van een programma.

Bij 'C'-programmering zijn de functies onderverdeeld in twee typen:

Bibliotheekfuncties
Door de gebruiker gedefinieerde functies

Het verschil tussen de bibliotheek en door de gebruiker gedefinieerde functies in C is dat we geen code hoeven te schrijven voor een bibliotheekfunctie. Het is al aanwezig in het header-bestand dat we altijd aan het begin van een programma opnemen. U hoeft alleen maar de naam van een functie te typen en deze samen met de juiste syntaxis te gebruiken. Printf, scanf zijn de voorbeelden van een bibliotheekfunctie.

Terwijl een door de gebruiker gedefinieerde functie een type functie is waarin we een hoofdgedeelte van een functie moeten schrijven en de functie moeten aanroepen wanneer we de functie nodig hebben om een bewerking in ons programma uit te voeren.

Een door de gebruiker gedefinieerde functie in C wordt altijd door de gebruiker geschreven, maar kan later deel uitmaken van de 'C'-bibliotheek. Het is een groot voordeel van 'C'-programmering.

C-programmeerfuncties zijn onderverdeeld in drie activiteiten, zoals,

Functie verklaring
Functie definitie
Functie-oproep

Functie Verklaring

Functieverklaring betekent het schrijven van een naam van een programma. Het is een verplicht onderdeel voor het gebruik van functies in code. In een functiedeclaratie specificeren we gewoon de naam van een functie die we in ons programma gaan gebruiken, zoals een variabele declaratie. We kunnen een functie niet gebruiken tenzij deze in een programma is gedeclareerd. Een functie verklaring wordt ook wel "Function prototype ."

De functieverklaringen (prototype genoemd) worden meestal gedaan boven de functie main () en nemen de algemene vorm aan:

return_data_type function_name (data_type arguments);

Het return_data_type : is het gegevenstype van de waardefunctie die wordt teruggestuurd naar de aanroepende instructie.
De functienaam : wordt gevolgd door haakjes
Argumentennamen met hun gegevenstypedeclaraties worden optioneel tussen haakjes geplaatst.

We beschouwen het volgende programma dat laat zien hoe je een kubusfunctie declareert om de kubuswaarde van een integer-variabele te berekenen

#include /*Function declaration*/int add(int a,b);/*End of Function declaration*/int main() {

Houd er rekening mee dat een functie niet noodzakelijk een waarde retourneert. In dit geval wordt het trefwoord void gebruikt.

De functiedeclaratie output_message geeft bijvoorbeeld aan dat de functie geen waarde retourneert: void output_message ();

Functie definitie

Functiedefinitie betekent gewoon het schrijven van de hoofdtekst van een functie. Een body van een functie bestaat uit statements die een specifieke taak gaan uitvoeren. Een functielichaam bestaat uit een enkele of een blok met instructies. Het is ook een verplicht onderdeel van een functie.

int add(int a,int b) //function body{int c;c=a+b;return c;}

Functie-oproep

Een functieaanroep betekent het aanroepen van een functie wanneer deze nodig is in een programma. Telkens wanneer we een functie aanroepen, voert deze een bewerking uit waarvoor deze is ontworpen. Een functieaanroep is een optioneel onderdeel in een programma.

 result = add(4,5);

Hier is de volledige code:

#include int add(int a, int b); //function declarationint main(){int a=10,b=20;int c=add(10,20); //function callprintf("Addition:%d\n",c);getch();}int add(int a,int b) //function body{int c;c=a+b;return c;}

Uitgang:

Addition:30

Functieargumenten

De argumenten van een functie worden gebruikt om de benodigde waarden te ontvangen door de functieaanroep. Ze zijn afgestemd op positie; het eerste argument wordt doorgegeven aan de eerste parameter, het tweede aan de tweede parameter enzovoort.

Standaard worden de argumenten doorgegeven met een waarde waarin een kopie van de gegevens wordt gegeven aan de aangeroepen functie. De feitelijk doorgegeven variabele zal niet veranderen.

We beschouwen het volgende programma dat parameters laat zien die door waarde zijn doorgegeven:

int add (int x, int y);int main() {int a, b, result;a = 5;b = 10;result = add(a, b);printf("%d + %d\ = %d\n", a, b, result);return 0;}int add (int x, int y) {x += y;return(x);}

De programma-output is:

5 + 10 = 15

Houd er rekening mee dat de waarden van a en b zijn doorgegeven aan de functie add, niet zijn gewijzigd, omdat alleen de waarde ervan is doorgegeven aan de parameter x.

Variabele reikwijdte

Variabel bereik betekent de zichtbaarheid van variabelen binnen een code van het programma.

In C zijn variabelen die binnen een functie worden gedeclareerd, lokaal voor dat codeblok en kan er niet naar worden verwezen buiten de functie. Variabelen die buiten alle functies worden gedeclareerd, zijn echter globaal en toegankelijk vanuit het hele programma. Constanten gedeclareerd met een #define bovenaan een programma zijn toegankelijk vanuit het hele programma. We beschouwen het volgende programma dat de waarde van de globale variabele afdrukt vanuit zowel de hoofdfunctie als de door de gebruiker gedefinieerde functie:

#include int global = 1348;void test();int main() {printf("from the main function : global =%d \n", global);test () ;return 0;}void test (){printf("from user defined function : global =%d \n", global);}

Resultaat:

from the main function : global =1348from user defined function : global =1348

We bespreken de programmadetails:

We declareren een integer globale variabele met 1348 als beginwaarde.
We declareren en definiëren een functie test () die geen argumenten accepteert en geen waarde retourneert. Deze functie drukt alleen de globale variabele waarde af om aan te tonen dat de globale variabelen overal in het programma toegankelijk zijn.
We printen de globale variabele binnen de hoofdfunctie.
We roepen de functie test aan om de globale variabele waarde af te drukken.

In C, wanneer argumenten worden doorgegeven aan functieparameters, fungeren de parameters als lokale variabelen die worden vernietigd bij het verlaten van de functie.

Wanneer u globale variabelen gebruikt, moet u deze voorzichtig gebruiken, omdat ze tot fouten kunnen leiden en ze overal in een programma kunnen wijzigen. Ze moeten worden geïnitialiseerd voordat ze worden gebruikt.

Statische variabelen

De statische variabelen hebben een lokaal bereik. Ze worden echter niet vernietigd bij het verlaten van de functie. Daarom behoudt een statische variabele zijn waarde voor altijd en is deze toegankelijk wanneer de functie opnieuw wordt ingevoerd. Een statische variabele wordt geïnitialiseerd wanneer deze wordt gedeclareerd en heeft het voorvoegsel static nodig.

Het volgende programma gebruikt een statische variabele:

#include void say_hi();int main() {int i;for (i = 0; i < 5; i++) { say_hi();}return 0;}void say_hi() {static int calls_number = 1;printf("Hi number %d\n", calls_number);calls_number ++; }

Het programma toont:

Hi number 1Hi number 2Hi number 3Hi number 4Hi number 5

Recursieve functies

Beschouw de faculteit van een getal dat als volgt wordt berekend 6! = 6 * 5 * 4 * 3 * 2 * 1.

Deze berekening wordt gedaan door herhaaldelijk feit * (feit -1) te berekenen totdat feit gelijk is aan 1.

Een recursieve functie is een functie die zichzelf aanroept en een uitgangsvoorwaarde bevat om de recursieve aanroepen te beëindigen. In het geval van de berekening van het faculteitnummer is de uitgangsvoorwaarde feit gelijk aan 1. Recursie werkt door oproepen te "stapelen" totdat de uitgangsvoorwaarde waar is.

Bijvoorbeeld:

#include int factorial(int number);int main() {int x = 6;printf("The factorial of %d is %d\n", x, factorial(x));return 0;}int factorial(int number) {if (number == 1) return (1); /* exiting condition */elsereturn (number * factorial(number - 1));}

Het programma toont:

 The factorial of 6 is 720

Hier bespreken we programmadetails:

We declareren onze recursieve factoriële functie die een integerparameter aanneemt en de faculteit van deze parameter retourneert. Deze functie zal zichzelf aanroepen en het aantal verlagen tot de exit, of de basisvoorwaarde is bereikt. Als de voorwaarde waar is, worden de eerder gegenereerde waarden met elkaar vermenigvuldigd en wordt de laatste factoriële waarde geretourneerd.
We declareren en initialiseren een integervariabele met waarde "6" en drukken vervolgens de faculteitwaarde af door onze faculteitfunctie aan te roepen.

Bekijk de volgende tabel om meer inzicht te krijgen in het recursieve mechanisme dat erin bestaat de functie zichzelf aan te roepen totdat het basisscenario of de stopconditie is bereikt, en daarna verzamelen we de vorige waarden:

Inline-functies

Functie in C-programmering wordt gebruikt om de meest gebruikte instructies op te slaan. Het wordt gebruikt om het programma te modulariseren.

Telkens wanneer een functie wordt aangeroepen, springt de instructieaanwijzer naar de functiedefinitie. Na het uitvoeren van een functie valt de instructiepointer terug op de instructie van waaruit hij naar de functiedefinitie is gesprongen.

Elke keer dat we functies gebruiken, hebben we een extra wijzer nodig om naar de functiedefinitie te springen en terug te keren naar de instructie. Om de noodzaak van dergelijke aanwijzerkoppen te elimineren, gebruiken we inline-functies.

In een inline-functie wordt een functieaanroep direct vervangen door een daadwerkelijke programmacode. Het springt niet naar een blok omdat alle bewerkingen worden uitgevoerd binnen de inline-functie.

Inline-functies worden meestal gebruikt voor kleine berekeningen. Ze zijn niet geschikt als het om grote computers gaat.

Een inline-functie is vergelijkbaar met de normale functie, behalve dat het trefwoord inline vóór de functienaam wordt geplaatst. Inline-functies worden gemaakt met de volgende syntaxis:

inline function_name (){//function definition}

Laten we een programma schrijven om een inline-functie te implementeren.

inline int add(int a, int b) //inline function declaration{return(a+b);}int main(){int c=add(10,20);printf("Addition:%d\n",c);getch();}

Uitgang:

Addition: 30

Bovenstaand programma demonstreert het gebruik van een inline-functie voor het optellen van twee getallen. Zoals we kunnen zien, hebben we de toevoeging op twee getallen binnen de inline-functie alleen geretourneerd zonder extra regels te schrijven. Tijdens de functieaanroep hebben we zojuist waarden doorgegeven waarop we moeten optellen.

Overzicht

Een functie is een miniprogramma of een subprogramma.
Functies worden gebruikt om het programma te modulariseren.
Bibliotheek en door de gebruiker gedefinieerd zijn twee soorten functies.
Een functie bestaat uit een declaratie, een functie-body en een functie-aanroepgedeelte.
Functieverklaring en body zijn verplicht.
Een functieaanroep kan optioneel zijn in een programma.
C-programma heeft minstens één functie; het is de belangrijkste functie ().
Elke functie heeft een naam, gegevenstype van retourwaarde of een leegte, parameters.
Elke functie moet worden gedefinieerd en gedeclareerd in uw C-programma.
Houd er rekening mee dat gewone variabelen in een C-functie worden vernietigd zodra we de functieaanroep verlaten.
De argumenten die aan een functie worden doorgegeven, worden niet gewijzigd omdat ze de waarde none per adres hebben doorgegeven.
Het bereik van de variabele wordt de zichtbaarheid van variabelen binnen een programma genoemd
Er zijn globale en lokale variabelen in C-programmering