C Functies Beheersen: Praktische Voorbeelden van Recursie & Inline Technieken

Wat is een Functie in C?

Functie in C-programmeren is een herbruikbaar blok code dat een programma makkelijker te begrijpen, testen en kan worden gewijzigd zonder het aanroepende programma te veranderen. Functies verdelen de code en modulariseren het programma voor betere en effectievere resultaten. Kortom, een groter programma wordt verdeeld in diverse subprogramma's die functies genoemd worden.

Wanneer je een groot programma in verschillende functies verdeelt, wordt het makkelijk om elke functie individueel te beheren. Wanneer een fout optreedt in het programma, kun je eenvoudig de foutieve functies onderzoeken en alleen die fouten corrigeren. Je kunt functies eenvoudig aanroepen en gebruiken wanneer ze nodig zijn, wat automatisch leidt tot tijd- en ruimtebesparing.

In deze tutorial leer je:

• Bibliotheek vs. Gebruiker-gedefinieerde Functies
• Functie Declaratie
• Functie Definitie
• Functie Aanroep
• Functie Argumenten
• Variabele Scope
• Statische Variabelen
• Recursieve Functies
• Inline Functies

Bibliotheek vs. Gebruiker-gedefinieerde Functies

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

In C-programmeren zijn functies verdeeld in twee typen:

1. Bibliotheekfuncties
2. Gebruiker-gedefinieerde functies

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

Terwijl een gebruiker-gedefinieerde functie een type functie is waarin we een functie-body moeten schrijven en de functie aanroepen wanneer we de functie nodig hebben om een operatie in ons programma uit te voeren.

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

C-programmeerfuncties zijn verdeeld in drie activiteiten:

1. Functie declaratie
2. Functie definitie
3. Functie aanroep

Functie Declaratie

Functie declaratie betekent de naam van een programma schrijven. Het is een verplicht onderdeel voor het gebruik van functies in code. In een functie declaratie specificeren we alleen de naam van een functie die we in ons programma gaan gebruiken, net als een variabele declaratie. We kunnen een functie niet gebruiken tenzij deze in een programma gedeclareerd is. Een functie declaratie heet ook "Functie prototype."

De functie declaraties (genaamd prototype) worden meestal boven de main()-functie gedaan en hebben de algemene vorm:

retour_datatype functie_naam (datatype argumenten);

• Het retour_datatype: is het datatype van de waarde die de functie teruggeeft naar de aanroepende statement.
• De functie_naam: wordt gevolgd door haakjes.
• Argumenten namen met hun datatype declaraties optioneel binnen de haakjes geplaatst.

We bekijken het volgende programma dat laat zien hoe een kubus-functie te declareren om de kubuswaarde van een integer-variabele te berekenen:

#include <stdio.h>
/*Functie declaratie*/
int optellen(int a,b);
/*Einde functie declaratie*/
int main() {

Houd er rekening mee dat een functie niet noodzakelijk een waarde hoeft te retourneren. In dat geval wordt het sleutelwoord void gebruikt.

Bijvoorbeeld, de declaratie van de output_message-functie geeft aan dat de functie geen waarde retourneert: void output_message();

Functie Definitie

Functie definitie betekent gewoon de body van een functie schrijven. Een body van een functie bestaat uit statements die een specifieke taak gaan uitvoeren. Een functie-body bestaat uit een enkele of een blok statements. Het is ook een verplicht onderdeel van een functie.

int optellen(int a,int b) //functie-body
{
    int c;
    c=a+b;
    return c;
}

Functie Aanroep

Een functie-aanroep betekent een functie aanroepen wanneer deze vereist is in een programma. Wanneer we een functie aanroepen, voert het een operatie uit waarvoor het ontworpen was. Een functie-aanroep is een optioneel onderdeel van een programma.

resultaat = optellen(4,5);

Hier is de complete code:

#include <stdio.h>
int optellen(int a, int b); //functie declaratie
int main() {
    int a=10,b=20;
    int c=optellen(10,20); //functie aanroep
    printf("Optelling:%d\n",c);
    getch();
}
int optellen(int a,int b) //functie-body
{
    int c;
    c=a+b;
    return c;
}

Output:

Optelling:30

Functie Argumenten

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

Standaard worden argumenten per waarde doorgegeven, waarbij een kopie van de data aan de aangeroepen functie wordt gegeven. De daadwerkelijk doorgegeven variabele verandert niet.

We bekijken het volgende programma dat parameters doorgegeven per waarde demonstreert:

int optellen (int x, int y);
int main() {
    int a, b, resultaat;
    a = 5;
    b = 10;
    resultaat = optellen(a, b);
    printf("%d + %d = %d\n", a, b, resultaat);
    return 0;
}
int optellen (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 die aan de optellen-functie doorgegeven werden, niet veranderden omdat alleen de waarde werd doorgegeven aan parameter x.

Variabele Scope

Variabele scope betekent de zichtbaarheid van variabelen binnen een programmacode.

In C zijn variabelen die binnen een functie gedeclareerd zijn, lokaal voor dat codeblok en kunnen niet buiten de functie worden aangesproken. Variabelen die buiten alle functies gedeclareerd zijn, zijn globaal en toegankelijk vanuit het gehele programma. Constanten gedeclareerd met #define bovenaan een programma zijn toegankelijk vanuit het hele programma. We bekijken het volgende programma dat de waarde van de globale variabele print vanuit zowel main als gebruiker-gedefinieerde functie:

#include <stdio.h>
int globaal = 1348;
void test();
int main() {
    printf("uit de main-functie: globaal =%d \n", globaal);
    test();
    return 0;
}
void test() {
    printf("uit gebruiker-gedefinieerde functie: globaal =%d \n", globaal);
}

Resultaat:

uit de main-functie: globaal =1348
uit gebruiker-gedefinieerde functie: globaal =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 accepteert en geen waarde retourneert. Deze functie print alleen de globale variabele waarde om te demonstreren dat globale variabelen overal in het programma toegankelijk zijn.
3. We printen de globale variabele binnen de main-functie.
4. We roepen de test-functie aan om de globale variabele waarde te printen.

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

Wanneer je globale variabelen gebruikt, wees voorzichtig omdat ze tot fouten kunnen leiden en overal in een programma kunnen veranderen. Ze moeten geïnitialiseerd zijn voordat ze gebruikt worden.

Statische Variabelen

Statische variabelen hebben een lokale scope. Echter, ze worden niet vernietigd bij het verlaten van de functie. Daarom behoudt een statische variabele zijn waarde voor altijd en kan worden benaderd wanneer de functie opnieuw wordt betreden. Een statische variabele wordt geïnitialiseerd bij declaratie en heeft de prefix static nodig.

Het volgende programma gebruikt een statische variabele:

#include <stdio.h>
void zeg_hoi();
int main() {
    int i;
    for (i = 0; i < 5; i++) {
        zeg_hoi();
    }
    return 0;
}
void zeg_hoi() {
    static int aantal_aanroepen = 1;
    printf("Hoi nummer %d\n", aantal_aanroepen);
    aantal_aanroepen++;
}

Het programma toont:

Hoi nummer 1
Hoi nummer 2
Hoi nummer 3
Hoi nummer 4
Hoi nummer 5

Recursieve Functies

Overweeg de faculteit van een getal die als volgt berekend wordt: 6! = 6 * 5 * 4 * 3 * 2 * 1.

Deze berekening wordt gedaan door herhaaldelijk fact * (fact -1) te berekenen tot fact 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 faculteitsberekening is de exit-voorwaarde fact gelijk aan 1. Recursie werkt door "stacking" aanroepen totdat de exit-voorwaarde true is.

Bijvoorbeeld:

#include <stdio.h>
int faculteit(int getal);
int main() {
    int x = 6;
    printf("De faculteit van %d is %d\n", x, faculteit(x));
    return 0;
}
int faculteit(int getal) {
    if (getal == 1) return (1); /* exit-voorwaarde */
    else return (getal * faculteit(getal - 1));
}

Het programma toont:

De faculteit van 6 is 720

Hier bespreken we de programmadetails:

1. We declareren onze recursieve faculteit-functie die een integer-parameter accepteert en de faculteit van deze parameter retourneert. Deze functie roept zichzelf aan en verlaagt het getal tot de exit- of basisvoorwaarde bereikt is. Wanneer de voorwaarde true is, worden de eerder gegenereerde waarden met elkaar vermenigvuldigd, en de finale faculteitswaarde wordt geretourneerd.
2. We declareren en initialiseren een integer-variabele met waarde "6" en printen vervolgens de faculteitswaarde door onze faculteit-functie aan te roepen.

Overweeg het volgende diagram om het recursieve mechanisme beter te begrijpen, dat bestaat uit het aanroepen van de functie zichzelf totdat de basisgeval of stopvoorwaarde bereikt is, en daarna verzamelen we de eerdere waarden:

Inline Functies

Functie in C-programmeren wordt gebruikt om de meest frequente instructies op te slaan. Het wordt gebruikt voor het modulariseren van het programma.

Wanneer een functie aangeroepen wordt, springt de instructiepointer naar de functiedefinitie. Na het uitvoeren van een functie, valt de instructiepointer terug naar de statement waarvandaan het naar de functiedefinitie sprong.

Wanneer we functies gebruiken, hebben we een extra pointer-head nodig om naar de functiedefinitie te springen en terug te keren naar de statement. Om de noodzaak van dergelijke pointer-heads te elimineren, gebruiken we inline-functies.

In een inline-functie wordt een functie-aanroep direct vervangen door de daadwerkelijke programmacode. Er springt niet naar een blok omdat alle operaties binnen de inline-functie worden uitgevoerd.

Inline-functies worden meestal gebruikt voor kleine berekeningen. Ze zijn niet geschikt wanneer grote berekeningen betrokken zijn.

Een inline-functie lijkt op een normale functie, behalve dat het sleutelwoord inline voor de functienaam wordt geplaatst. Inline-functies worden aangemaakt met de volgende syntaxis:

inline functie_naam() {
    //functie-definitie
}

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

inline int optellen(int a, int b) //inline functie declaratie
{
    return(a+b);
}
int main() {
    int c=optellen(10,20);
    printf("Optelling:%d\n",c);
    getch();
}

Output:

Optelling: 30

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

Samenvatting

• Een functie is een mini-programma of subprogramma.
• Functies worden gebruikt om het programma te modulariseren.
• Bibliotheek- en gebruiker-gedefinieerde zijn twee typen functies.
• Een functie bestaat uit een declaratie, functie-body en een functie-aanroep-deel.
• Functie-declaratie en body zijn verplicht.
• Een functie-aanroep kan optioneel zijn in een programma.
• C-programma heeft ten minste één functie; het is de main-functie().
• Elke functie heeft een naam, datatype van retourwaarde of void, parameters.
• Elke functie moet gedefinieerd en gedeclareerd zijn in je C-programma.
• Houd er rekening mee dat gewone variabelen in een C-functie vernietigd worden zodra we de functie-aanroep verlaten.
• De argumenten die aan een functie doorgegeven worden, veranderen niet omdat ze per waarde doorgegeven worden, niet per adres.
• De variabele scope wordt aangeduid als de zichtbaarheid van variabelen binnen een programma.
• Er zijn globale en locale variabelen in C-programmeren.