0Pricing
C Academy · Lezione

Analizzare le opzioni

Gestire i flag

Analizzare le opzioni è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Opzioni e argomenti posizionali

Gli argomenti della riga di comando sono di due tipi. Gli argomenti posizionali sono valori come i nomi dei file. Le opzioni (chiamate anche flag) iniziano con un trattino, ad esempio -v o --help.

Questa lezione mostra come rilevare e gestire manualmente i flag.

#include <stdio.h>

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-')
            printf("option: %s\n", argv[i]);
        else
            printf("value:  %s\n", argv[i]);
    }
    return 0;
}

Rilevamento di un flag

Per verificare un flag specifico, confronti ogni argomento con strcmp.

Qui impostiamo un booleano quando troviamo -v, che attiva la modalità dettagliata.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0)
            verbose = 1;
    }
    printf("verbose = %d\n", verbose);
    return 0;
}

Supporto delle opzioni lunghe

Molti strumenti accettano sia una forma breve (-h) sia una forma lunga (--help).

Verifichi entrambe le forme con due confronti uniti da ||.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-h") == 0 ||
            strcmp(argv[i], "--help") == 0) {
            printf("Usage: prog [options]\n");
            return 0;
        }
    }
    printf("No help requested\n");
    return 0;
}

Opzioni che accettano un valore

Alcuni flag richiedono un argomento, come -o output.txt. Quando si incontra un flag di questo tipo, l'elemento successivo di argv è il suo valore.

Incrementi l'indice del ciclo e verifichi di non aver superato la fine.

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

int main(int argc, char *argv[]) {
    const char *output = "default.txt";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-o") == 0 && i + 1 < argc) {
            output = argv[++i];
        }
    }
    printf("Output file: %s\n", output);
    return 0;
}

Gestione del valore mancante

Se -o è l'ultimo argomento, non esiste alcun valore dopo di esso. Leggere argv[i+1] supererebbe i limiti dell'array.

Verifichi sempre i + 1 < argc prima di consumare il token successivo e, in caso contrario, segnali un errore.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-n") == 0) {
            if (i + 1 >= argc) {
                printf("Error: -n needs a value\n");
                return 1;
            }
            printf("n = %s\n", argv[++i]);
        }
    }
    return 0;
}

Combinazione di flag booleani e valori

Un parser realistico tiene traccia contemporaneamente di diversi flag: alcuni booleani, altri associati a valori. Utilizzi variabili separate per ogni impostazione.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    const char *name = "world";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0) verbose = 1;
        else if (strcmp(argv[i], "-name") == 0 && i+1 < argc) name = argv[++i];
    }
    if (verbose) printf("verbose mode\n");
    printf("Hello, %s\n", name);
    return 0;
}

Riconoscimento della fine delle opzioni

Per convenzione, un -- isolato indica la fine delle opzioni. Tutto ciò che segue viene trattato come argomento posizionale, anche se inizia con un trattino.

In questo modo gli utenti possono passare nomi di file che iniziano con -.

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

int main(int argc, char *argv[]) {
    int opts_done = 0;
    for (int i = 1; i < argc; i++) {
        if (!opts_done && strcmp(argv[i], "--") == 0) {
            opts_done = 1;
            continue;
        }
        printf("%s: %s\n", opts_done ? "value" : "token", argv[i]);
    }
    return 0;
}

Raccolta degli argomenti posizionali

Spesso si desiderano flag insieme a un elenco di file. Ignori le opzioni riconosciute e memorizzi il resto come argomenti posizionali.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-') continue;
        printf("file: %s\n", argv[i]);
    }
    return 0;
}

Gestione delle opzioni sconosciute

Uno strumento intuitivo segnala i flag sconosciuti invece di ignorarli silenziosamente. Verifichi ogni flag rispetto alle opzioni note e, in caso contrario, mostri un avviso.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] != '-') continue;
        if (strcmp(argv[i], "-v") != 0)
            printf("Unknown option: %s\n", argv[i]);
    }
    return 0;
}

Conversione dei valori delle opzioni

I valori delle opzioni arrivano come stringhe. Converta quelli numerici con strtol, che segnala anche gli errori di analisi tramite un puntatore alla fine.

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

int main(int argc, char *argv[]) {
    int count = 1;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-c") == 0 && i+1 < argc)
            count = (int) strtol(argv[++i], NULL, 10);
    }
    printf("count = %d\n", count);
    return 0;
}

Perché è utile un parser reale

L'analisi manuale funziona, ma diventa complessa con flag brevi combinati (-vf), la sintassi con = (--name=foo) e le regole sull'ordine.

La funzione standard getopt, illustrata di seguito, gestisce queste convenzioni al posto Suo.

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Parsed %d tokens manually\n", argc - 1);
    return 0;
}

Verifica rapida

Verifichi la Sua comprensione delle difficoltà dell'analisi delle opzioni.

Riepilogo

Ha imparato ad analizzare manualmente le opzioni:

  • I flag iniziano con -; li confronti con strcmp.
  • Supporti le forme brevi e lunghe con ||.
  • Le opzioni che accettano un valore consumano il token successivo: verifichi i + 1 < argc.
  • -- termina l'analisi delle opzioni; segnali i flag sconosciuti e converta i valori numerici con strtol.

Domande Frequenti

La lezione «Analizzare le opzioni» è gratuita?

Sì — il testo completo di «Analizzare le opzioni» è 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 «Analizzare le opzioni»?

Gestire i flag 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 2 di 4.

Quanto tempo richiede la lezione «Analizzare le opzioni»?

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. argc e argv
  2. Analizzare le opzioni
  3. getopt
  4. Creare uno strumento CLI
← Torna a C Academy