Functies in C-programmering met voorbeelden: recursief en inline

Wat is een functie in C?

Functie in C-programmering Een functie is een herbruikbaar codeblok dat een programma begrijpelijker en testbaarder maakt en dat eenvoudig kan worden aangepast zonder het aanroepende programma te wijzigen. Functies verdelen de code en modulariseren het programma voor betere en effectievere resultaten. Kortom, een groter programma wordt opgedeeld in verschillende subprogramma's, die functies worden genoemd.

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:

1. Bibliotheekfuncties
2. 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:

1. Functiedeclaratie
2. Functiedefinitie
3. Functie oproep

Functie Verklaring

Een functiedeclaratie betekent het schrijven van een naam voor een programma. Het is een verplicht onderdeel voor het gebruik van functies in code. In een functiedeclaratie specificeren we simpelweg de naam van een functie die we in ons programma gaan gebruiken, net zoals bij een variabeledeclaratie. We kunnen een functie niet gebruiken tenzij deze in een programma is gedeclareerd. Een functiedeclaratie wordt ook wel een "functieprototype" genoemd.

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

return_data_type function_name (data_type arguments);

• De return_data_type: is het gegevenstype van de waarde die de functie teruggeeft aan de aanroepende instructie.
• De functienaam: wordt gevolgd door haakjes.
• Argumentnamen, eventueel aangevuld met hun gegevenstype, worden 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);

Hieronder staat 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 worden de argumenten doorgegeven via waardeoverdracht, waarbij een kopie van de gegevens aan de aangeroepen functie wordt gegeven. De daadwerkelijk 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 kunnen ze niet buiten de functie worden aangeroepen. Variabelen die buiten alle functies worden gedeclareerd, zijn echter globaal en toegankelijk vanuit het hele programma. Constanten die bovenaan een programma met een `#define` worden gedeclareerd, zijn ook toegankelijk vanuit het hele programma. We bekijken het volgende programma dat de waarde van een globale variabele afdrukt vanuit zowel de `main`-functie als een 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 details van het programma:

1. We declareren een globale variabele met geheel getal met 1348 als beginwaarde.
2. 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.
3. We printen de globale variabele binnen de hoofdfunctie.
4. 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

Neem bijvoorbeeld de faculteit van een getal, die 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:

1. 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.
2. 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 herhaaldelijk aanroepen van de functie totdat de basiscase of het einde is bereikt.ping Als aan de voorwaarde is voldaan, verzamelen we vervolgens de voorgaande 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();
}

Output:

Addition: 30

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

Veelgestelde vragen