0Pricing
C Academy · Lektion

Optionen parsen

Flags verarbeiten

Optionen parsen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Optionen und Positionsargumente

Befehlszeilenargumente gibt es in zwei Varianten. Positionsargumente sind Werte wie Dateinamen. Optionen (auch Flags genannt) beginnen mit einem Bindestrich, etwa -v oder --help.

In dieser Lektion erfahren Sie, wie Sie Flags manuell erkennen und verarbeiten.

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

Ein Flag erkennen

Um ein bestimmtes Flag zu prüfen, vergleichen Sie jedes Argument mit strcmp.

Hier setzen wir einen booleschen Wert, sobald wir -v für den ausführlichen Modus sehen.

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

Lange Optionen unterstützen

Viele Werkzeuge akzeptieren sowohl eine Kurzform (-h) als auch eine Langform (--help).

Prüfen Sie mit zwei durch || verbundenen Vergleichen auf beide Schreibweisen.

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

Optionen mit Wert

Einige Flags benötigen ein Argument, etwa -o output.txt. Wenn Sie ein solches Flag sehen, ist das nächste Element von argv sein Wert.

Erhöhen Sie den Schleifenindex und prüfen Sie, dass Sie nicht über das Ende hinausgelaufen sind.

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

Fehlenden Wert behandeln

Wenn -o das letzte Argument ist, folgt kein Wert. Das Lesen von argv[i+1] würde außerhalb des gültigen Bereichs liegen.

Prüfen Sie immer i + 1 < argc, bevor Sie das nächste Token verwenden, und melden Sie andernfalls einen Fehler.

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

Boolesche Flags und Werte kombinieren

Ein realistischer Parser verwaltet mehrere Flags gleichzeitig: einige boolesch, andere mit Werten. Verwenden Sie für jede Einstellung eine eigene Variable.

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

Das Ende der Optionen erkennen

Konventionell markiert ein einzelnes -- das Ende der Optionen. Alles danach wird als Positionsargument behandelt, selbst wenn es mit einem Bindestrich beginnt.

So können Benutzer Dateinamen übergeben, die mit - beginnen.

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

Positionsargumente sammeln

Oft benötigen Sie Flags und zusätzlich eine Liste von Dateien. Überspringen Sie die erkannten Optionen und speichern Sie den Rest als Positionsargumente.

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

Unbekannte Optionen behandeln

Ein benutzerfreundliches Werkzeug meldet unbekannte Flags, anstatt sie stillschweigend zu ignorieren. Vergleichen Sie sie mit Ihren bekannten Optionen und geben Sie andernfalls eine Warnung aus.

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

Optionswerte umwandeln

Optionswerte kommen als Zeichenketten an. Wandeln Sie numerische Werte mit strtol um; diese Funktion meldet über einen Endzeiger auch Analysefehler.

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

Warum ein echter Parser hilfreich ist

Manuelles Parsen funktioniert, wird aber bei kombinierten kurzen Flags (-vf), der =-Syntax (--name=foo) und Regeln zur Reihenfolge schnell unübersichtlich.

Die standardmäßige Funktion getopt, die als Nächstes behandelt wird, übernimmt diese Konventionen für Sie.

#include <stdio.h>

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

Schnelltest

Testen Sie Ihr Verständnis typischer Probleme beim Parsen von Optionen.

Zusammenfassung

Sie haben das manuelle Parsen von Optionen gelernt:

  • Flags beginnen mit -; vergleichen Sie sie mit strcmp.
  • Unterstützen Sie Kurz- und Langformen mit ||.
  • Optionen mit Wert verbrauchen das nächste Token – sichern Sie dies mit i + 1 < argc ab.
  • -- beendet das Parsen von Optionen; melden Sie unbekannte Flags und wandeln Sie numerische Werte mit strtol um.

Häufig gestellte Fragen

Ist die Lektion „Optionen parsen“ kostenlos?

Ja — der vollständige Text von „Optionen parsen“ 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 „Optionen parsen“?

Flags verarbeiten 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 2 von 4.

Wie lange dauert die Lektion „Optionen parsen“?

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

  1. argc und argv
  2. Optionen parsen
  3. getopt
  4. Ein CLI-Tool erstellen
← Zurück zu C Academy