C Academy · Les

De stdarg-macro's

va_list, va_start, va_arg

Les 1 van 413 stappen

De stdarg-macro's is een gratis C Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C Academy bevat in totaal 4 lessen.

Wat zijn variadische functies?

Een variadische functie accepteert een variabel aantal argumenten. Je hebt er al een gebruikt: printf kan een willekeurig aantal waarden ontvangen.

Met C kun je zelf zulke functies schrijven met de macro's uit <stdarg.h>.

#include <stdio.h>

int main(void) {
    printf("%d %d %d\n", 1, 2, 3);
    printf("%s\n", "any count of args");
    return 0;
}

Het beletselteken

Je declareert een variadische functie met ... (het beletselteken) als laatste parameter.

Daarvoor moet minstens één benoemde parameter staan, zodat de functie weet waar het variabele gedeelte begint.

#include <stdio.h>
#include <stdarg.h>

void demo(int count, ...) {
    printf("This function takes %d extra args\n", count);
}

int main(void) {
    demo(3, 10, 20, 30);
    return 0;
}

stdarg.h opnemen

Om de variabele argumenten te lezen, heb je #include <stdarg.h> nodig.

Dit definieert het type va_list en de macro's va_start, va_arg en va_end.

#include <stdio.h>
#include <stdarg.h>

void show(int n, ...) {
    va_list args;
    va_start(args, n);
    va_end(args);
    printf("set up and cleaned up\n");
}

int main(void) {
    show(2, 5, 6);
    return 0;
}

va_list en va_start

Declareer een variabele van het type va_list om de huidige positie bij te houden. Roep vervolgens va_start(list, last) aan en geef de laatste benoemde parameter mee.

Hiermee wijst de lijst naar het eerste variabele argument.

#include <stdio.h>
#include <stdarg.h>

void first(int count, ...) {
    va_list args;
    va_start(args, count);
    int value = va_arg(args, int);
    printf("first variadic arg = %d\n", value);
    va_end(args);
}

int main(void) {
    first(1, 99);
    return 0;
}

va_arg: waarden lezen

va_arg(list, type) retourneert het volgende argument en schuift de lijst op. Je moet het exacte type opgeven dat moet worden gelezen.

Elke aanroep gaat één argument verder.

#include <stdio.h>
#include <stdarg.h>

void three(int n, ...) {
    va_list args;
    va_start(args, n);
    int a = va_arg(args, int);
    int b = va_arg(args, int);
    int c = va_arg(args, int);
    printf("%d %d %d\n", a, b, c);
    va_end(args);
}

int main(void) {
    three(3, 7, 8, 9);
    return 0;
}

va_end: opruimen

Roep altijd va_end(list) aan wanneer je klaar bent met lezen. Deze functie voert alle opruimwerkzaamheden uit die het platform nodig heeft.

Als je dit vergeet, leidt dat op sommige systemen tot ongedefinieerd gedrag.

#include <stdio.h>
#include <stdarg.h>

int add_two(int dummy, ...) {
    va_list args;
    va_start(args, dummy);
    int sum = va_arg(args, int) + va_arg(args, int);
    va_end(args);
    return sum;
}

int main(void) {
    printf("%d\n", add_two(0, 4, 6));
    return 0;
}

Weten hoeveel argumenten er zijn

De macro's kunnen je niet vertellen hoeveel argumenten zijn doorgegeven. Je moet dat zelf aangeven.

Een gebruikelijke aanpak is een parameter met het aantal vooraan, zoals in sum(3, a, b, c).

#include <stdio.h>
#include <stdarg.h>

int sum(int count, ...) {
    va_list args;
    va_start(args, count);
    int total = 0;
    for (int i = 0; i < count; i++)
        total += va_arg(args, int);
    va_end(args);
    return total;
}

int main(void) {
    printf("%d\n", sum(4, 1, 2, 3, 4));
    return 0;
}

Een sentinelwaarde gebruiken

Een andere manier om het einde aan te geven is een sentinel: een speciale afsluitende waarde die de aanroeper moet opnemen, zoals -1 of NULL.

Herhaal de lus totdat je de sentinel leest.

#include <stdio.h>
#include <stdarg.h>

int sum_until_neg(int first, ...) {
    va_list args;
    va_start(args, first);
    int total = first, v;
    while ((v = va_arg(args, int)) != -1)
        total += v;
    va_end(args);
    return total;
}

int main(void) {
    printf("%d\n", sum_until_neg(10, 20, 30, -1));
    return 0;
}

Standaardpromoties van argumenten

Variadische argumenten ondergaan standaardpromoties: char en short worden int, en float wordt double.

Lees kleine gehele getallen met va_arg dus altijd als int en kommagetallen als double.

#include <stdio.h>
#include <stdarg.h>

void show_double(int n, ...) {
    va_list args;
    va_start(args, n);
    double d = va_arg(args, double);
    printf("%.2f\n", d);
    va_end(args);
}

int main(void) {
    show_double(1, 3.5f);
    return 0;
}

Een va_list kopiëren

Als je de argumenten twee keer moet doorlopen, gebruik je va_copy(dest, src) om de lijst te dupliceren voordat je gaat lezen.

Je kunt een va_list na va_end niet opnieuw gebruiken zonder opnieuw te beginnen met va_start.

#include <stdio.h>
#include <stdarg.h>

void twice(int n, ...) {
    va_list a, b;
    va_start(a, n);
    va_copy(b, a);
    printf("%d %d\n", va_arg(a, int), va_arg(b, int));
    va_end(a);
    va_end(b);
}

int main(void) {
    twice(1, 42);
    return 0;
}

Een gemiddelde berekenen

Door het patroon met een aantal te combineren met het lezen van kommagetallen, kunnen we het gemiddelde berekenen van een lijst met variadisch doorgegeven getallen.

#include <stdio.h>
#include <stdarg.h>

double average(int count, ...) {
    va_list args;
    va_start(args, count);
    double sum = 0;
    for (int i = 0; i < count; i++)
        sum += va_arg(args, double);
    va_end(args);
    return sum / count;
}

int main(void) {
    printf("%.2f\n", average(3, 2.0, 4.0, 6.0));
    return 0;
}

Korte controle

Controleer of je de macro's van stdarg begrijpt.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt het mechanisme voor variadische argumenten geleerd:

Declareer met ... na minstens één benoemde parameter.
va_start(list, last) begint, va_arg(list, type) leest en va_end(list) ruimt op.
De macro's kennen het aantal niet — gebruik een parameter met het aantal of een sentinel.
Let op standaardpromoties: lees kleine gehele getallen als int en kommagetallen als double.

Gratis beginnen

Leer C met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “De stdarg-macro's” gratis?

Ja — de volledige tekst van “De stdarg-macro's” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus C Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus C Academy bevat in totaal 4 lessen.

Wat leer ik in “De stdarg-macro's”?

va_list, va_start, va_arg Je oefent met C Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C Academy te beginnen?

Ervaring vooraf is niet nodig. C Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “De stdarg-macro's”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C Academy?

Ja. Elke les over C Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C Academy