C Academy · Lektion

getopt

Standardmäßiges Parsen von Optionen

getopt ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist getopt?

getopt ist eine POSIX-Funktion, die Einzelzeichenoptionen nach den üblichen Unix-Konventionen für Sie parst.

Sie befindet sich in <unistd.h> und erspart Ihnen den größten Teil des wiederkehrenden Codes beim manuellen Parsen von Flags.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "v")) != -1) {
        if (opt == 'v') printf("verbose on\n");
    }
    return 0;
}

Die optstring

Das dritte Argument von getopt ist die optstring: eine Liste zulässiger Optionsbuchstaben.

"abc" bedeutet, dass -a, -b und -c als boolesche Flags akzeptiert werden.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "abc")) != -1) {
        printf("saw option -%c\n", opt);
    }
    return 0;
}

Die Parseschleife

getopt gibt bei jedem Aufruf das nächste Optionszeichen zurück oder -1, wenn keine Optionen mehr vorhanden sind.

Das übliche Muster ist eine while-Schleife mit einem darin enthaltenen switch, der anhand des zurückgegebenen Zeichens verzweigt.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "xy")) != -1) {
        switch (opt) {
            case 'x': printf("x set\n"); break;
            case 'y': printf("y set\n"); break;
        }
    }
    return 0;
}

Optionen mit Argumenten

Setzen Sie im optstring hinter einen Buchstaben einen Doppelpunkt, um anzugeben, dass er einen Wert benötigt. "o:" bedeutet, dass -o ein Argument erfordert.

Der Wert steht anschließend in der globalen Variable optarg zur Verfügung.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "o:")) != -1) {
        if (opt == 'o') printf("output = %s\n", optarg);
    }
    return 0;
}

Flags und Optionen mit Werten kombinieren

Sie können boolesche Optionen und Optionen mit Werten in einem optstring mischen. Hier ist -v ein Flag und -n erwartet eine Zahl.

getopt ermöglicht es Benutzern außerdem, Flags zu bündeln, etwa -vn 5.

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

int main(int argc, char *argv[]) {
    int opt, verbose = 0, n = 0;
    while ((opt = getopt(argc, argv, "vn:")) != -1) {
        if (opt == 'v') verbose = 1;
        else if (opt == 'n') n = atoi(optarg);
    }
    printf("verbose=%d n=%d\n", verbose, n);
    return 0;
}

Unbekannte Optionen behandeln

Wenn getopt auf eine Option trifft, die nicht im optstring enthalten ist, gibt es '?' zurück und gibt einen Fehler aus (sofern Sie dies nicht unterdrücken).

Fügen Sie einen case '?' hinzu, um fehlerhafte Eingaben angemessen zu behandeln.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        switch (opt) {
            case 'a': printf("a\n"); break;
            case '?': printf("unknown option\n"); break;
        }
    }
    return 0;
}

Erforderliche Argumente fehlen

Wenn eine Option mit Wert ohne ihren Wert angegeben wird, hängt das Verhalten von getopt vom optstring ab.

Beginnt der optstring mit einem Doppelpunkt (":o:"), gibt getopt bei einem fehlenden Argument ':' zurück, sodass Sie den Fehler präzise melden können.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, ":f:")) != -1) {
        if (opt == 'f') printf("file=%s\n", optarg);
        else if (opt == ':') printf("option needs a value\n");
    }
    return 0;
}

optind: Wo das Parsen endete

Nach der Schleife enthält optind den Index des ersten Nichtoptionsarguments in argv.

Verwenden Sie ihn, um die verbleibenden Positionsargumente wie Dateinamen zu verarbeiten.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "v")) != -1) { }
    for (int i = optind; i < argc; i++)
        printf("positional: %s\n", argv[i]);
    return 0;
}

Meldungen von getopt unterdrücken

Standardmäßig gibt getopt eigene Fehlermeldungen nach stderr aus. Setzen Sie die globale Variable opterr auf 0, um diese Meldungen zu unterdrücken und Fehler selbst zu behandeln.

#include <stdio.h>
#include <unistd.h>

extern int opterr;

int main(int argc, char *argv[]) {
    opterr = 0;
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        if (opt == '?') printf("bad option, handled quietly\n");
    }
    return 0;
}

Das fehlerhafte Option erkennen

Wenn getopt '?' zurückgibt, enthält die globale Variable optopt das betreffende Optionszeichen.

So können Sie eine hilfreiche Meldung ausgeben, die genau angibt, welches Flag falsch war.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        if (opt == '?')
            printf("Unrecognized option: -%c\n", optopt);
    }
    return 0;
}

Hinweis zu langen Optionen

Das einfache getopt unterstützt nur Optionen aus einem Buchstaben. Für lange Optionen wie --verbose stellen GNU-Systeme getopt_long in <getopt.h> bereit.

Es verwendet dieselbe Schleife, ergänzt sie aber um eine Tabelle mit Deskriptoren für lange Optionen.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    printf("getopt parses %d short options\n", argc > 1 ? argc - 1 : 0);
    return 0;
}

Schnelltest

Testen Sie Ihr Verständnis der Syntax von getopt-Optstrings.

Zusammenfassung

Sie haben das standardmäßige Parsen von Optionen mit getopt gelernt:

Führen Sie die Schleife aus, solange getopt(argc, argv, optstring) nicht -1 ist, und verzweigen Sie mit einem switch.
Ein Doppelpunkt hinter einem Buchstaben bedeutet, dass dieser einen Wert erwartet, der in optarg zu finden ist.
optind zeigt anschließend auf das erste Positionsargument.
Die globalen Variablen opterr und optopt sowie ein vorangestellter Doppelpunkt steuern die Fehlerbehandlung.

Häufig gestellte Fragen

Ist die Lektion „getopt“ kostenlos?

Ja — der vollständige Text von „getopt“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „getopt“?

Standardmäßiges Parsen von Optionen Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „getopt“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy