Argomenti da riga di comando in C: argc, argv e parsing sicuro

A ogni programma che esegui da un terminale si possono passare argomenti: gcc -Wall hello.c -o hello ne passa quattro. I tuoi programmi C leggono i propri tramite due parametri di main, e il meccanismo è tutto qui: nessuna chiamata di libreria, nessuna configurazione.

La firma

Finora ogni esempio di questa documentazione ha usato int main(void). L'altra forma standard riceve la riga di comando:

int main(int argc, char *argv[]) {
    /* ... */
}

• argc ("argument count") è il numero di argomenti, compreso il nome del programma.
• argv ("argument vector") è un array di stringhe. char *argv[] significa "array di puntatori a char", cioè un array di stringhe C.

char **argv è una scrittura equivalente che vedrai altrettanto spesso; i parametri array decadono a puntatori, quindi le due dichiarano la stessa cosa.

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("argc = %d\n", argc);

    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = \"%s\"\n", i, argv[i]);
    }

    printf("argv[%d] = %s\n", argc, argv[argc] == NULL ? "NULL" : "non nullo");
    return 0;
}

Usa il pannello Args dell'editor per fornire gli argomenti (ogni campo è un argomento), poi premi Run. Prova con tre campi: hello, world, 42.

Com'è fatto

Eseguire ./greet Ada Lovelace produce:

Quattro fatti da memorizzare:

• argc vale almeno 1 in pratica, perché argv[0] è il nome del programma. Gli argomenti veri partono dall'indice 1, ed è per questo che i cicli su di essi partono da i = 1.
• Tutto è una stringa. ./prog 42 ti dà "42", i due caratteri, mai il numero 42. Convertirlo spetta a te.
• argv[argc] è NULL. Lo garantisce lo standard, quindi se preferisci puoi percorrere l'array senza argc: for (char **p = argv + 1; *p != NULL; p++).
• È la shell a dividere le parole, non il tuo programma. ./prog "Ada Lovelace" è un solo argomento; le virgolette vengono consumate dalla shell e non arrivano mai in argv.

Controllare prima di leggere

Un argomento non passato non è una stringa vuota: è memoria che non hai alcun diritto di toccare. Valida sempre prima argc:

#include <stdio.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "uso: %s NOME\n", argv[0]);
        return 1;
    }

    printf("Ciao, %s!\n", argv[1]);
    return 0;
}

Due convenzioni in questo programmino, entrambe standard negli strumenti Unix:

• Il messaggio di utilizzo va su stderr, non su stdout, così non sporca l'output che viene inviato altrove con una pipe.
• Un valore di ritorno diverso da zero da main segnala un fallimento a chiunque abbia eseguito il programma. 0 significa successo; qualsiasi altro valore significa che qualcosa è andato storto. Gli script di shell lo controllano.

Stampare argv[0] invece di un nome scritto a mano fa sì che il messaggio corrisponda a come l'utente ha invocato il programma, anche se è stato rinominato o raggiunto da un percorso diverso.

Convertire gli argomenti numerici

argv[1] è testo. Per fare calcoli devi convertirlo, e la funzione da usare è strtol di <stdlib.h>:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <limits.h>

/* Restituisce 1 se riesce e salva il valore; 0 se il testo non è un intero pulito. */
int parse_int(const char *text, long *out) {
    char *end;
    errno = 0;
    long value = strtol(text, &end, 10);

    if (end == text)        return 0;   /* nessuna cifra             */
    if (*end != '\0')       return 0;   /* caratteri in più: "12abc" */
    if (errno == ERANGE)    return 0;   /* fuori dall'intervallo di long */

    *out = value;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "uso: %s NUMERO...\n", argv[0]);
        return 1;
    }

    long total = 0;
    for (int i = 1; i < argc; i++) {
        long n;
        if (!parse_int(argv[i], &n)) {
            fprintf(stderr, "%s: non e' un intero: %s\n", argv[0], argv[i]);
            return 1;
        }
        total += n;
    }

    printf("somma = %ld\n", total);
    return 0;
}

Aggiungi 10, 20, 30 come tre campi Args, poi sostituiscine uno con banana per vedere il percorso di errore.

Il terzo parametro di strtol è la base: 10 per il decimale, 16 per l'esadecimale, oppure 0 per rilevarla automaticamente da un prefisso 0x o da uno zero iniziale. Il secondo indica dove salvare un puntatore al primo carattere non consumato, ed è questo che rende possibile il controllo degli errori:

• end == text significa che non ha letto nulla: l'argomento non iniziava con un numero.
• *end != '\0' significa che dopo il numero c'era altro testo, quindi "12abc" viene rifiutato invece di diventare 12 in silenzio.
• errno == ERANGE significa che il valore ha superato i limiti di long.

Confronta con atoi, che è più breve e non può segnalare nulla di tutto ciò:

int n = atoi(argv[1]);   /* "banana" -> 0, "0" -> 0, overflow -> indefinito */

atoi restituisce 0 per un input non valido, indistinguibile da un vero zero. Usa strtol (e strtod per la virgola mobile) ogni volta che l'input arriva dall'esterno del programma. Approfondimenti in conversione di stringhe.

Una piccola calcolatrice

Mettiamo tutto insieme: un programma che riceve un numero, un operatore e un numero:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int parse_double(const char *text, double *out) {
    char *end;
    double v = strtod(text, &end);
    if (end == text || *end != '\0') {
        return 0;
    }
    *out = v;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "uso: %s NUMERO OPERATORE NUMERO\n", argv[0]);
        fprintf(stderr, "  operatori: + - x /   (usa x, non *, cosi' la shell non lo tocca)\n");
        return 1;
    }

    double a, b;
    if (!parse_double(argv[1], &a) || !parse_double(argv[3], &b)) {
        fprintf(stderr, "%s: entrambi gli operandi devono essere numeri\n", argv[0]);
        return 1;
    }

    const char *op = argv[2];
    double result;

    if      (strcmp(op, "+") == 0) result = a + b;
    else if (strcmp(op, "-") == 0) result = a - b;
    else if (strcmp(op, "x") == 0) result = a * b;
    else if (strcmp(op, "/") == 0) {
        if (b == 0.0) {
            fprintf(stderr, "%s: divisione per zero\n", argv[0]);
            return 1;
        }
        result = a / b;
    } else {
        fprintf(stderr, "%s: operatore sconosciuto \"%s\"\n", argv[0], op);
        return 1;
    }

    printf("%g\n", result);
    return 0;
}

Prova 12 + 30, poi 7 x 6, poi 5 / 0.

Nota strcmp(op, "+") == 0 invece di op == "+". Confrontare valori char * con == confronta gli indirizzi, non il contenuto, e risulterebbe falso anche per testi identici. Vedi le funzioni per le stringhe.

La x al posto di * è un dettaglio del mondo reale: la maggior parte delle shell espande un * isolato nell'elenco dei file della directory corrente prima ancora che il tuo programma parta. Metterlo tra virgolette ('*') funziona, ma scegliere un carattere che la shell ignora è più comodo.

Parsing dei flag

Per convenzione le opzioni iniziano con -. Un semplice ciclo scritto a mano gestisce i casi comuni:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[]) {
    int verbose = 0;
    long count = 1;
    const char *message = NULL;

    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            verbose = 1;
        } else if (strcmp(argv[i], "-n") == 0) {
            if (i + 1 >= argc) {                 /* il valore deve esistere */
                fprintf(stderr, "%s: -n richiede un numero\n", argv[0]);
                return 1;
            }
            count = strtol(argv[++i], NULL, 10); /* consuma l'argomento successivo */
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "%s: opzione sconosciuta %s\n", argv[0], argv[i]);
            return 1;
        } else {
            message = argv[i];
        }
    }

    if (message == NULL) {
        fprintf(stderr, "uso: %s [-v] [-n NUMERO] MESSAGGIO\n", argv[0]);
        return 1;
    }

    if (verbose) {
        printf("stampo \"%s\" %ld volta/e\n", message, count);
    }
    for (long i = 0; i < count; i++) {
        printf("%s\n", message);
    }
    return 0;
}

Provalo con quattro campi Args: -v, -n, 3, hello.

Il controllo i + 1 >= argc prima di argv[++i] è la riga importante: un'opzione che si aspetta un valore deve verificare che il valore ci sia davvero, altrimenti -n come ultimo argomento legge oltre la fine dell'array. Sui sistemi Unix reali getopt di <unistd.h> fa tutto questo per te, comprese le opzioni brevi raggruppate come -vn3; conviene usarlo quando un programma ha più di due o tre flag.

Argomenti nell'editor del browser

I blocchi editor di questa pagina vengono compilati ed eseguiti per te, e il pannello Args è dove fornisci quello che in un terminale seguirebbe il nome del programma. Ogni campo che aggiungi con Add arg diventa esattamente una voce in argv: in mezzo non c'è nessuna shell, quindi niente viene diviso sugli spazi e non servono virgolette: un campo che contiene hello world arriva come l'unico argomento hello world. Per passare -n 3 hello, aggiungi tre campi. Lasciare il pannello vuoto dà argc == 1: ecco perché il controllo argc < 2 scatta alla prima esecuzione, ed ecco perché vale la pena scriverlo.

Errori comuni

• Leggere argv[1] senza controllare argc. Comportamento indefinito quando non sono stati passati argomenti, e il crash più comune in quest'area.
• Far partire il ciclo da i = 0. Così elabori il nome del programma come se fosse un dato.
• Trattare argv[1] come un numero. È testo finché non lo converti.
• Usare atoi sull'input dell'utente. Non c'è modo di distinguere un argomento errato da uno zero.
• Confrontare stringhe con ==. Usa strcmp.
• Scrivere nelle stringhe di argv. Modificarle è consentito dallo standard, ma lo spazio è limitato e dipende dalla piattaforma; copiale in un tuo buffer se devi cambiare qualcosa.