Functies in C-programmering met voorbeelden:recursief en 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 moduleren het programma voor betere en effectieve resultaten. Kortom, een groter programma is verdeeld in verschillende subprogramma's die als functies worden aangeroepen

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

In deze tutorial leer je-

• Bibliotheek Vs. Door de gebruiker gedefinieerde functies
• Functieverklaring
• Functiedefinitie
• Functie-oproep
• Functieargumenten
• Variabel bereik
• 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 willekeurig aantal functies hebben. De hoofdfunctie () in C is een startpunt van een programma.

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

1. Bibliotheekfuncties
2. 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 headerbestand dat we altijd aan het begin van een programma opnemen. U hoeft alleen de naam van een functie in te voeren en deze samen met de juiste syntaxis te gebruiken. Printf, scanf zijn voorbeelden van een bibliotheekfunctie.

Terwijl een door de gebruiker gedefinieerde functie een type functie is waarin we een hoofdtekst 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,

1. Functieverklaring
2. Functiedefinitie
3. Functie-oproep

Functieverklaring

Functiedeclaratie 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 als een variabeledeclaratie. We kunnen een functie niet gebruiken tenzij deze in een programma is gedeclareerd. Een functiedeclaratie wordt ook wel “Functie prototype . genoemd .”

De functiedeclaraties (prototype genoemd) worden meestal gedaan boven de hoofdfunctie () en hebben de algemene vorm:

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
• Argumenten namen met hun gegevenstypeverklaringen optioneel worden tussen haakjes geplaatst.

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

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

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

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

Functiedefinitie

Functiedefinitie betekent alleen 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 functie-aanroep betekent het aanroepen van een functie wanneer dit in een programma vereist is. Telkens wanneer we een functie aanroepen, voert deze een bewerking uit waarvoor deze is ontworpen. Een functie-aanroep is een optioneel onderdeel van een programma.

  result = add(4,5);

Hier is de volledige code:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

Uitvoer:

Addition:30

Functieargumenten

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

Standaard worden de argumenten op waarde doorgegeven waarin een kopie van gegevens wordt gegeven aan de aangeroepen functie. De daadwerkelijk 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 uitvoer van het programma is:

5 + 10 = 15

Houd er rekening mee dat de waarden van a en b die werden doorgegeven om de functie toe te voegen, niet werden gewijzigd omdat alleen de waarde ervan werd doorgegeven aan de parameter x.

Variabel bereik

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 buiten de functie worden verwezen. 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 van zowel de hoofdfunctie als de door de gebruiker gedefinieerde functie:

#include <stdio.h>
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 =1348
from user defined function : global =1348

We bespreken de programmadetails:

1. We declareren een integer globale variabele met 1348 als initiële waarde.
2. We declareren en definiëren een test()-functie die geen argumenten aanneemt en ook 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.
3. We drukken de globale variabele af binnen de hoofdfunctie.
4. We roepen de testfunctie aan om de globale variabelewaarde 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 veranderen. 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 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 <stdio.h>
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 1
Hi number 2
Hi number 3
Hi number 4
Hi 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 als het herhaaldelijk berekenen van feit * (feit -1) totdat feit gelijk is aan 1.

Een recursieve functie is een functie die zichzelf aanroept en een exit-voorwaarde bevat om de recursieve aanroepen te beëindigen. In het geval van de berekening van het faculteitsnummer is de exit-voorwaarde in feite gelijk aan 1. Recursie werkt door oproepen te "stapelen" totdat de exit-voorwaarde waar is.

Bijvoorbeeld:

#include <stdio.h>
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 */
  else
    return (number * factorial(number - 1));
}

Het programma toont:

 The factorial of 6 is 720

Hier bespreken we programmadetails:

1. We declareren onze recursieve faculteitsfunctie die een integer-parameter nodig heeft en de faculteit van deze parameter retourneert. Deze functie roept zichzelf op en verlaagt het nummer totdat de exit- of basisconditie is bereikt. Als de voorwaarde waar is, worden de eerder gegenereerde waarden met elkaar vermenigvuldigd en wordt de uiteindelijke faculteitswaarde geretourneerd.
2. We declareren en initialiseren een integer-variabele met waarde "6" en drukken vervolgens de faculteitswaarde af door onze faculteitsfunctie aan te roepen.

Overweeg de volgende grafiek om meer inzicht te krijgen in het recursieve mechanisme dat erin bestaat de functie zelf aan te roepen totdat het basisgeval 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 instructiewijzer naar de functiedefinitie. Na het uitvoeren van een functie valt de instructieaanwijzer terug naar de instructie van waaruit hij naar de functiedefinitie is gesprongen.

Telkens wanneer we functies gebruiken, hebben we een extra aanwijzer 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 functie-aanroep 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();
}

Uitvoer:

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 functie-aanroep hebben we zojuist waarden doorgegeven waarop we moeten optellen.

Samenvatting

• 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 functietekst en een functieaanroepgedeelte.
• Functieverklaring en hoofdtekst zijn verplicht.
• Een functie-aanroep kan optioneel zijn in een programma.
• C programma heeft tenminste één functie; het is de hoofdfunctie ().
• Elke functie heeft een naam, gegevenstype van retourwaarde of een void, 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 zijn doorgegeven, worden niet gewijzigd omdat ze zijn doorgegeven met de waarde geen per adres.
• Het bereik van de variabele wordt de zichtbaarheid van variabelen binnen een programma genoemd
• Er zijn globale en lokale variabelen in C-programmering