0Pricing
C Academy · Lezione

Macro stdarg

va_list, va_start, va_arg

Macro stdarg è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Che cosa sono le funzioni variadiche?

Una funzione variadica accetta un numero variabile di argomenti. Ne ha già utilizzata una: printf può accettare un numero qualsiasi di valori.

In C è possibile scriverne di proprie usando le macro di <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;
}

I puntini di sospensione

Si dichiara una funzione variadica con ... (i puntini di sospensione) come ultimo parametro.

Prima di esso deve essere presente almeno un parametro denominato, così la funzione sa dove inizia la parte variabile.

#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;
}

Inclusione di stdarg.h

Per leggere gli argomenti variabili è necessario #include <stdarg.h>.

Questo definisce il tipo va_list e le macro va_start, va_arg e 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 e va_start

Dichiari una variabile va_list per tenere traccia della posizione corrente. Quindi chiami va_start(list, last), passando l'ultimo parametro denominato.

In questo modo l'elenco punta al primo argomento variabile.

#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: lettura dei valori

va_arg(list, type) restituisce l'argomento successivo e fa avanzare l'elenco. È necessario indicare il tipo esatto da leggere.

Ogni chiamata avanza di un argomento.

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

Chiami sempre va_end(list) quando ha finito di leggere. Esegue tutte le operazioni di pulizia necessarie alla piattaforma.

Dimenticarlo causa un comportamento indefinito su alcuni sistemi.

#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;
}

Sapere quanti argomenti

Le macro non possono dirLe quanti argomenti sono stati passati. Deve indicarlo esplicitamente.

Un approccio comune consiste nell'usare un parametro iniziale per il conteggio, come 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;
}

Usare un valore sentinella

Un altro modo per indicare la fine consiste nell'usare una sentinella: un valore speciale di terminazione che il chiamante deve includere, come -1 o NULL.

Continui il ciclo finché non legge la sentinella.

#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;
}

Promozioni predefinite degli argomenti

Gli argomenti variadici subiscono le promozioni predefinite: char e short diventano int, mentre float diventa double.

Con va_arg, legga quindi sempre gli interi piccoli come int e i valori in virgola mobile come 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;
}

Copiare una va_list

Se deve attraversare gli argomenti due volte, usi va_copy(dest, src) per duplicare la lista prima di leggerla.

Non può riutilizzare una va_list dopo va_end senza riavviarla tramite 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;
}

Calcolare una media

Combinando il modello basato sul conteggio con la lettura dei valori in virgola mobile, possiamo calcolare la media di un elenco di numeri passati in modo variadico.

#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;
}

Verifica rapida

Verifichi la Sua comprensione delle macro stdarg.

Riepilogo

Ha imparato il meccanismo variadico:

  • Dichiari la funzione con ... dopo almeno un parametro denominato.
  • va_start(list, last) avvia l'elaborazione, va_arg(list, type) legge gli argomenti e va_end(list) esegue la pulizia.
  • Le macro non conoscono il numero di argomenti: usi un parametro per il conteggio oppure una sentinella.
  • Consideri le promozioni predefinite: legga gli interi piccoli come int e i valori in virgola mobile come double.

Domande Frequenti

La lezione «Macro stdarg» è gratuita?

Sì — il testo completo di «Macro stdarg» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Macro stdarg»?

va_list, va_start, va_arg Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Macro stdarg»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Macro stdarg
  2. Scrivere funzioni simili a printf
  3. Problemi di sicurezza dei tipi
  4. Esempi pratici
← Torna a C Academy