Een inleiding tot C-functies

Misschien heb je de basissyntaxis van C behandeld, met eenvoudige voorbeelden, en vraag je je nu af hoe je grotere, echte programma's kunt maken. Om te beginnen wilt u uw code in efficiënte delen indelen, met een minimum aan herhaling. In C is, zoals in de meeste talen, het antwoord op uw problemen de functie.

Het maken en gebruiken van functies in C is eenvoudig en biedt veel voordelen. Met functies kunt u complexe programma's in kleinere stukjes opsplitsen. Ze bieden herbruikbaarheid, zowel binnen uw oorspronkelijke programma als in gerelateerde bibliotheken of andere afzonderlijke programma's.

Om te beginnen moet u meer weten over functiedeclaraties, prototypes, parameters en return-statements.

Wat zijn functies in C?

Bij C-programmeren, is een functie een benoemd codegedeelte dat iets doet wanneer u daarom vraagt. Het helpt je code overzichtelijk te houden en zorgt ervoor dat je dezelfde actie meerdere keren kunt gebruiken zonder jezelf te herhalen.

Het eenvoudigste voorbeeld is er een dat je al hebt gebruikt: de functie main(). De hoofdfunctie is bijzonder bijzonder omdat deze fungeert als het belangrijkste toegangspunt voor elk C-programma. U kunt ook bibliotheekfuncties gebruiken, die iemand anders al heeft geschreven, of u kunt uw eigen, door de gebruiker gedefinieerde functies schrijven.

Functies: Aangeven, Definiëren en Bellen

Deze drie aspecten zijn van fundamenteel belang voor het gebruik van functies.

Functieverklaring

Dit biedt informatie over de naam, het retourneringstype en de parameters van een functie, waardoor het gebruik ervan mogelijk wordt gemaakt vóór de volledige definitie ervan. Het wordt ook wel een functieprototype genoemd. Het volgt deze eenvoudige syntaxis:

return_type function_name(parameters);

Waar:

• retourtype is het gegevenstype van de waarde die de functie retourneert. Het kan elk geldig C-gegevenstype zijn of leegte als de functie geen waarde retourneert.
• functie_naam is de naam die u aan de functie geeft. U gebruikt dit om de functie later aan te roepen.
• parameters is een lijst met invoerparameters die de functie accepteert, indien aanwezig. Elke parameter bestaat uit een gegevenstype gevolgd door een parameternaam, gescheiden door komma's.

Hier is bijvoorbeeld een eenvoudige functiedeclaratie:

intadd(int a, int b);

Functiedefinitie

Wanneer u een functie aanroept, wordt de code uitgevoerd die in de definitie ervan is opgegeven. Het bevat de naam van de functie, het retourtype, de parameterlijst en de instructies die het gedrag ervan definiëren. Hier is de syntaxis:

return_type function_name(parameters){
// Function body - code that defines what the function does
// Return a value if applicable
return value;
}

Laten we delen van de syntaxis opsplitsen:

Functie lichaam: Dit is het codeblok tussen accolades {}. Het bevat de instructies die definiëren wat de functie doet wanneer deze wordt aangeroepen.

Retourverklaring: Als de functie een ander retourtype heeft dan leegte, de opbrengst statement stuurt een waarde terug naar de beller. Deze waarde moet overeenkomen met het opgegeven retourtype.

Hier is een eenvoudig voorbeeld van een functiedefinitie:

intadd(int a, int b){
int sum = a + b;
return sum;
}

Functie oproep

Net als bij koken heb je misschien een recept (functiedefinitie) en enkele ingrediënten (argumenten), maar moet je toch de instructies volgen om een ​​resultaat te krijgen. Een functieaanroep voert de functie uit met gegeven argumenten; hier is de syntaxis:

return_type result = function_name(arguments);

argumenten: dit zijn de waarden of expressies die u als invoer aan de functie doorgeeft. Scheid elk argument met een komma. Het aantal, de volgorde en de gegevenstypen van de argumenten moeten overeenkomen met de parameterlijst van de functie.

resultaat: Als de functie een ander retourtype heeft dan leegte, kunt u de geretourneerde waarde vastleggen met behulp van een variabele van het juiste gegevenstype.

Hier is een voorbeeld van een functieaanroep:

#include
// Function prototype
intadd(int a, int b);
intmain(){
int x = 5, y = 3;
// Call the function and store the result in 'sum'
int sum = add(x, y);
printf("The sum of %d and %d is %d\n", x, y, sum);
return0;
}
// Function definition
intadd(int a, int b){
return a + b;
}

Door deze drie stappen te volgen: de functie declareren, de implementatie ervan verzorgen en deze aanroepen met de juiste argumenten: u kunt functies effectief gebruiken om verschillende taken in uw bestand uit te voeren programma.

Functieparameters en retourwaarden

Parameters zijn variabelen die zijn gedeclareerd in de declaratie of definitie van de functie en die fungeren als tijdelijke aanduidingen voor de waarden die aan de functie worden doorgegeven wanneer deze wordt aangeroepen. Hiermee kunt u gegevens doorgeven aan de functie, zodat deze met die gegevens kan werken en deze kan manipuleren. Retourwaarden zijn de waarden die een functie produceert en terugstuurt naar de aanroeper.

Er zijn twee methoden om parameters door te geven.

Ga voorbij aan waarde

Met deze aanpak kopieert een functieaanroep de waarde van het feitelijke argument naar de parameter van de functie. Wijzigingen in de parameter binnen de functie hebben geen invloed op het oorspronkelijke argument.

Bijvoorbeeld:

#include
intsquare(int num){
 num = num * num;
return num;
}
intmain(){
int x = 5;
int y = square(x);
// Output: x and y after function call: 5 25
printf("x and y after function call: %d %d\n", x, y);
return0;
}

• De kwadratische functie heeft een geheel getalparameter nodig, num.
• De kwadratische functie berekent het kwadraat van num, werkt de waarde ervan bij en retourneert deze nieuwe waarde.
• De hoofdfunctie declareert een geheel getalvariabele, Xen kent er de waarde 5 aan toe.
• Vervolgens roept het de kwadraatfunctie aan en geeft deze de waarde x door. Het wijst het resultaat toe aan een tweede variabele, j.
• Na de functieaanroep drukt main de waarden van x en y af. De x-waarde blijft hetzelfde omdat het wijzigen van de num-parameter binnen het vierkant geen invloed heeft op de oorspronkelijke x.

Ga voorbij aan referentie

Met deze aanpak geeft u het geheugenadres (pointer) van een waarde door aan een functie. Wijzigingen in de parameter binnen de functie hebben invloed op de oorspronkelijke waarde daarbuiten.

Pointers, inclusief hun gebruik als parameters, zijn een van de aspecten van C die het anders maken dan een taal als Python.

#include
voidsquare(int *num){
 *num = *num * *num;
}
intmain(){
int x = 5;
 square(&x);
// Output: x after function call: 25
printf("x after function call: %d\n", x);
return0;
}

• De vierkant functie heeft een integer-pointer nodig (int *) parameter, num. Er wordt geen waarde geretourneerd.
• De kwadratische functie berekent het kwadraat van de waarde die num bevat en werkt die waarde bij met behulp van de pointer-dereferentie-operator, *.
• De voornaamst functie declareert een integer-variabele, Xen wijst er de waarde aan toe 5.
• Vervolgens wordt de vierkant functie met een verwijzing naar X met behulp van het adres van de operator: &X.
• Na de functieaanroep drukt main de waarde af van X, dat is nu 25 sinds de wijzigingen in *num binnen in de vierkant functie heeft invloed op het origineel X.

Samenvattend is het belangrijkste verschil tussen de twee methoden de manier waarop wijzigingen in de parameter binnen de functie de oorspronkelijke waarde daarbuiten beïnvloeden. Pass by value creëert een kopie, terwijl pass by reference (pointer) directe manipulatie van de originele waarde mogelijk maakt.

Andere talen hebben vaak een equivalent van de pointers van C, maar werken over het algemeen op een hoger niveau. Een voorbeeld is C#'s ondersteuning voor out-variabelen.

Ongeldige functies

Ongeldige functies in C-programmering zijn functies die geen waarde retourneren. Gebruik ze om acties of taken uit te voeren zonder resultaat. Ze kunnen hun parameters wijzigen met behulp van 'pass by reference', maar dat hoeft niet.

Hier is een voorbeeld van een void-functie:

#include
// Void function with no parameters
voidgreet(){
printf("Hello, MUO!");
}
intmain(){
// Call the void function, output: "Hello, MUO!"
 greet();
return0;
}

Leegtefuncties zijn handig voor het uitvoeren van acties, het afdrukken van berichten, het wijzigen van gegevens of het uitvoeren van taken zonder dat er een retourwaarde nodig is.

Ontdek functies in C-programmering

Door te oefenen met het creëren van functies vergroot u uw inzicht in en toepassing van C-programmering. Bovendien verbetert het de leesbaarheid van de code en het onderhoudsgemak. Duik in verschillende toepassingen van functies om hun voordelen te ontsluiten.

Als je de grondbeginselen van C-functies onder de knie hebt en jezelf wilt uitdagen, overweeg dan om je te verdiepen in recursie.