Functies in C-programmering met voorbeelden: recursief en inline

Wat is een functie in C?

Functie in C-programmering is een herbruikbaar codeblok dat het gemakkelijker maakt een programma te begrijpen, te testen en eenvoudig aan te passen zonder het aanroepende programma te wijzigen. Functies verdelen de code en modulariseren 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 eenvoudig om elke functie afzonderlijk te beheren. Wanneer er een fout in het programma optreedt, kunt u eenvoudig defecte functies onderzoeken en alleen die fouten corrigeren. Functies kunt u eenvoudig oproepen en gebruiken wanneer u ze nodig heeft, waardoor u automatisch tijd en ruimte bespaart.

Bibliotheek versus. Door de gebruiker gedefinieerde functies

Elk 'C'-programma heeft minstens éé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:

Bibliotheekfuncties
Door de gebruiker gedefinieerde functies

Het verschil tussen de bibliotheekfuncties en de door de gebruiker gedefinieerde functies in C is dat we geen code voor een bibliotheekfunctie hoeven te schrijven. Het is al aanwezig in het headerbestand 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.

Een door de gebruiker gedefinieerde functie is een type functie waarbij we een functielichaam moeten schrijven en de functie moeten aanroepen wanneer we willen dat de functie een bewerking in ons programma uitvoert.

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:

Functiedeclaratie
Functiedefinitie
Functie oproep

Functie Verklaring

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 eenvoudigweg de naam van een functie die we in ons programma gaan gebruiken, zoals een variabeledeclaratie. We kunnen een functie niet gebruiken tenzij deze in een programma is gedeclareerd. Een functiedeclaratie wordt ook wel “Functie” genoemd prototype. '

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

return_data_type function_name (data_type arguments);

Ocuco's Medewerkers return_data_type: is het gegevenstype van de waardefunctie die wordt teruggestuurd naar de aanroepende instructie.
Ocuco's Medewerkers functienaam: wordt gevolgd door haakjes
argumenten namen 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 gehele 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 trefwoord void gebruikt.

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

Functiedefinitie

Functiedefinitie betekent alleen maar het schrijven van de hoofdtekst van een functie. Een hoofdgedeelte van een functie bestaat uit instructies die een specifieke taak gaan uitvoeren. Een functielichaam bestaat uit een enkele of een blok 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. Wanneer we een functie aanroepen, voert deze een bewerking uit waarvoor deze is ontworpen. Een functieaanroep 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;
}

Output:

Addition:30

Functieargumenten

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

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

We beschouwen het volgende programma dat parameters demonstreert die per waarde worden 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 zijn doorgegeven om de functie op te tellen, niet zijn gewijzigd omdat alleen de waarde ervan is 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 a #define bovenaan een programma zijn toegankelijk vanuit het hele programma. We beschouwen het volgende programma dat de waarde van de globale variabele van zowel de hoofd- als de door de gebruiker gedefinieerde functie afdrukt:

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

We declareren een globale variabele met geheel getal met 1348 als beginwaarde.
We declareren en definiëren een test()-functie die geen argumenten accepteert en ook geen waarde retourneert. Deze functie drukt alleen de waarde van de globale variabele 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 testfunctie aan om de globale variabelewaarde af te drukken.

In C fungeren de parameters als lokale variabelen wanneer argumenten aan functieparameters worden doorgegeven. Deze worden vernietigd wanneer de functie wordt verlaten.

Wanneer u gebruik maken van globale variabelenGebruik ze met de nodige voorzichtigheid, omdat ze tot fouten kunnen leiden en ze overal in een programma kunnen veranderen. Ze moeten vóór gebruik worden geïnitialiseerd.

Statische variabelen

De statische variabelen hebben een lokale scope. Ze worden echter niet vernietigd bij het verlaten van de functie. Daarom behoudt een statische variabele zijn waarde voor altijd en kan deze worden benaderd 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 uitgevoerd door het herhaaldelijk berekenen van feit * (feit -1) totdat feit gelijk is aan 1.

Een recursieve functie is een functie die zichzelf aanroept en een exitvoorwaarde bevat om de recursieve aanroepen te beëindigen. In het geval van de berekening van faculteitsgetallen is de uitgangsvoorwaarde feitelijk gelijk aan 1. Recursie werkt door aanroepen te “stapelen” totdat de uitgangsvoorwaarde 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 de programmadetails:

We declareren onze recursieve factoriële functie die een geheel getalparameter nodig heeft en de faculteit van deze parameter retourneert. Deze functie roept zichzelf op en verlaagt het aantal totdat de uitgangs- of basisvoorwaarde is bereikt. Wanneer de voorwaarde waar is, worden de eerder gegenereerde waarden met elkaar vermenigvuldigd en wordt de uiteindelijke faculteitswaarde geretourneerd.
We declareren en initialiseren een geheel getalvariabele met de waarde "6" en drukken vervolgens de factoriële waarde ervan af door onze faculteitsfunctie aan te roepen.

Bekijk de volgende grafiek om het recursieve mechanisme beter te begrijpen. Dit mechanisme bestaat uit het aanroepen van de functie zelf totdat het basisgeval of de stopconditie is bereikt. 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 instructiewijzer terug naar de instructie van waaruit hij naar de functiedefinitie is gesprongen.

Wanneer we functies gebruiken, hebben we een extra nodig wijzer head 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. Er wordt niet naar een blok gesprongen, omdat alle bewerkingen binnen de inline-functie worden uitgevoerd.

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