Ausführbare C-Docs: Kommandozeilenargumente

Q: Was sind argc und argv in C?

Sie sind die beiden Parameter von int main(int argc, char *argv[]). argc ist die Anzahl der Kommandozeilenargumente einschließlich des Programmnamens; argv ist ein Array dieser Argumente als Zeichenketten. argv[0] ist der Programmname, argv[1] das erste echte Argument, und argv[argc] ist immer NULL.

Q: Wie übergibt man einem C-Programm Argumente?

Tippe sie im Terminal hinter den Namen der ausführbaren Datei: ./program hallo 42. Das ergibt argc == 3, mit argv[1] als Zeichenkette "hallo" und argv[2] als "42". Im Editor auf dieser Seite gehören die Argumente stattdessen in das Args-Feld.

Q: Wie wandelt man ein Kommandozeilenargument in C in ein int um?

Benutze strtol: char end; long n = strtol(argv[1], &end, 10); und prüfe dann, dass end nicht noch am Anfang steht (nichts gelesen) und dass end gleich '\0' ist (kein Rest). atoi ist kürzer, liefert aber 0 sowohl für "0" als auch für "banane" und kann daher keinen Fehler melden.

Q: Was ist argv[0] in C?

Der Name, mit dem das Programm aufgerufen wurde - typischerweise ./program oder der volle Pfad. Er ist nützlich in Benutzungshinweisen (fprintf(stderr, "Aufruf: %s DATEI\n", argv[0])), damit die Meldung dazu passt, wie der Benutzer es tatsächlich aufgerufen hat. In ungewöhnlichen Fällen kann er eine leere Zeichenkette sein, nimm also nicht an, dass er da ist.

Jedem Programm, das du aus einem Terminal startest, können Argumente übergeben werden: gcc -Wall hello.c -o hello übergibt vier davon. Deine eigenen C-Programme lesen ihre über zwei Parameter von main, und das ist der ganze Mechanismus - kein Bibliotheksaufruf, keine Einrichtung.

Die Signatur

Bisher hat jedes Beispiel in dieser Dokumentation int main(void) verwendet. Die andere Standardform nimmt die Kommandozeile entgegen:

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

argc („argument count") ist die Anzahl der Argumente, einschließlich des Programmnamens.
argv („argument vector") ist ein Array von Zeichenketten. char *argv[] bedeutet „Array von Zeigern auf char", also ein Array von C-Zeichenketten.

char **argv ist eine gleichwertige Schreibweise, die du genauso oft sehen wirst; Array-Parameter zerfallen zu Zeigern, die beiden deklarieren also dasselbe.

#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" : "nicht null");
    return 0;
}

Benutze das Args-Feld des Editors, um Argumente anzugeben (jedes Feld ist ein Argument), und drücke dann Run. Probiere drei Felder: hallo, welt, 42.

Der Aufbau

./greet Ada Lovelace auszuführen ergibt:

Index	Wert
`argv[0]`	`"./greet"`	der Programmname wie aufgerufen
`argv[1]`	`"Ada"`	erstes echtes Argument
`argv[2]`	`"Lovelace"`	zweites echtes Argument
`argv[3]`	`NULL`	der Abschluss
`argc`	`3`	Anzahl einschließlich `argv[0]`

Vier Tatsachen, die man sich merken sollte:

argc ist in der Praxis mindestens 1, weil argv[0] der Programmname ist. Echte Argumente beginnen bei Index 1, weshalb Schleifen über sie bei i = 1 starten.
Alles ist eine Zeichenkette. ./prog 42 gibt dir "42", die beiden Zeichen, nie die Zahl 42. Das Umwandeln ist deine Aufgabe.
argv[argc] ist NULL. Vom Standard garantiert, du kannst das Array also auch ohne argc durchlaufen: for (char **p = argv + 1; *p != NULL; p++).
Die Shell teilt die Wörter auf, nicht dein Programm. ./prog "Ada Lovelace" ist ein Argument; die Anführungszeichen verbraucht die Shell und sie erreichen argv nie.

Prüfen, bevor du liest

Ein nicht übergebenes Argument ist keine leere Zeichenkette - es ist Speicher, den du nicht anfassen darfst. Prüfe immer zuerst argc:

#include <stdio.h>

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

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

Zwei Konventionen in diesem winzigen Programm, beide unter Unix-Werkzeugen Standard:

Die Benutzungsmeldung geht nach stderr, nicht nach stdout, damit sie eine Ausgabe, die irgendwohin weitergeleitet wird, nicht verunreinigt.
Ein Rückgabewert ungleich null aus main signalisiert einen Fehlschlag an das, was das Programm gestartet hat. 0 bedeutet Erfolg, alles andere, dass etwas schiefging. Shell-Skripte prüfen das.

argv[0] statt eines fest eingetragenen Namens auszugeben sorgt dafür, dass die Meldung zu dem passt, wie der Benutzer das Programm aufgerufen hat - auch wenn es umbenannt oder über einen anderen Pfad erreicht wurde.

Numerische Argumente umwandeln

argv[1] ist Text. Um zu rechnen, musst du ihn umwandeln, und die dafür zuständige Funktion ist strtol aus <stdlib.h>:

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

/* Liefert 1 bei Erfolg und speichert den Wert; 0, wenn der Text keine saubere Ganzzahl ist. */
int parse_int(const char *text, long *out) {
    char *end;
    errno = 0;
    long value = strtol(text, &end, 10);

    if (end == text)        return 0;   /* ueberhaupt keine Ziffern  */
    if (*end != '\0')       return 0;   /* Rest dahinter: "12abc"    */
    if (errno == ERANGE)    return 0;   /* ausserhalb des long-Bereichs */

    *out = value;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Aufruf: %s ZAHL...\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: keine ganze Zahl: %s\n", argv[0], argv[i]);
            return 1;
        }
        total += n;
    }

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

Füge 10, 20, 30 als drei Args-Felder hinzu, und ersetze dann eines durch banane, um den Fehlerpfad zu sehen.

Der dritte Parameter von strtol ist die Basis: 10 für dezimal, 16 für hexadezimal oder 0, um sie an einem 0x- oder führenden Nullpräfix automatisch zu erkennen. Der zweite ist der Ort, an dem ein Zeiger auf das erste nicht verbrauchte Zeichen abgelegt wird, und genau das macht die Fehlerprüfung möglich:

end == text bedeutet, dass nichts gelesen wurde - das Argument begann nicht mit einer Zahl.
*end != '\0' bedeutet, dass hinter der Zahl Text übrig war, "12abc" wird also abgelehnt, statt still zu 12 zu werden.
errno == ERANGE bedeutet, dass der Wert long überschritten hat.

Vergleiche mit atoi, das kürzer ist und nichts davon melden kann:

int n = atoi(argv[1]);   /* "banane" -> 0, "0" -> 0, Überlauf -> undefiniert */

atoi liefert 0 für ungültige Eingaben, was von einer echten Null nicht zu unterscheiden ist. Verwende strtol (und strtod für Gleitkommazahlen), wann immer die Eingabe von außerhalb deines Programms kommt. Mehr unter Zeichenkettenumwandlung.

Ein kleiner Rechner

Alles zusammen - ein Programm, das eine Zahl, einen Operator und eine Zahl entgegennimmt:

#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, "Aufruf: %s ZAHL OPERATOR ZAHL\n", argv[0]);
        fprintf(stderr, "  Operatoren: + - x /   (benutze x, nicht *, damit die Shell es in Ruhe laesst)\n");
        return 1;
    }

    double a, b;
    if (!parse_double(argv[1], &a) || !parse_double(argv[3], &b)) {
        fprintf(stderr, "%s: beide Operanden muessen Zahlen sein\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: Division durch null\n", argv[0]);
            return 1;
        }
        result = a / b;
    } else {
        fprintf(stderr, "%s: unbekannter Operator \"%s\"\n", argv[0], op);
        return 1;
    }

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

Probiere 12 + 30, dann 7 x 6, dann 5 / 0.

Beachte strcmp(op, "+") == 0 statt op == "+". char *-Werte mit == zu vergleichen vergleicht Adressen, nicht Inhalte, und wäre selbst bei identischem Text falsch. Siehe Zeichenkettenfunktionen.

Das x statt * ist ein Detail aus der Praxis: Die meisten Shells ersetzen ein nacktes * durch die Liste der Dateien im aktuellen Verzeichnis, bevor dein Programm überhaupt läuft. Es zu quoten ('*') funktioniert auch, aber ein Zeichen zu wählen, das die Shell ignoriert, ist freundlicher.

Optionen auswerten

Optionen beginnen konventionell mit -. Eine einfache selbstgeschriebene Schleife deckt die üblichen Fälle ab:

#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) {                 /* der Wert muss existieren */
                fprintf(stderr, "%s: -n braucht eine Zahl\n", argv[0]);
                return 1;
            }
            count = strtol(argv[++i], NULL, 10); /* das naechste Argument verbrauchen */
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "%s: unbekannte Option %s\n", argv[0], argv[i]);
            return 1;
        } else {
            message = argv[i];
        }
    }

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

    if (verbose) {
        printf("gebe \"%s\" %ld mal aus\n", message, count);
    }
    for (long i = 0; i < count; i++) {
        printf("%s\n", message);
    }
    return 0;
}

Probiere es mit vier Args-Feldern: -v, -n, 3, hallo.

Die Prüfung i + 1 >= argc vor argv[++i] ist die wichtige Zeile: Eine Option, die einen Wert erwartet, muss bestätigen, dass der Wert tatsächlich da ist, sonst liest -n als letztes Argument über das Ende des Arrays hinaus. Auf echten Unix-Systemen erledigt getopt aus <unistd.h> all das für dich, einschließlich gebündelter Kurzoptionen wie -vn3; danach zu greifen lohnt sich, sobald ein Programm mehr als zwei oder drei Optionen hat.

Argumente im Browser-Editor

Die Editorblöcke auf dieser Seite werden für dich kompiliert und ausgeführt, und im Args-Feld tippst du, was in einem Terminal hinter dem Programmnamen stünde. Jedes Feld, das du mit Add arg hinzufügst, wird zu genau einem Eintrag in argv - dazwischen steht keine Shell, es wird also nichts an Leerzeichen getrennt und es sind keine Anführungszeichen nötig: ein Feld mit dem Inhalt hallo welt kommt als das einzelne Argument hallo welt an. Um -n 3 hallo zu übergeben, füge drei Felder hinzu. Ein leeres Feld ergibt argc == 1 - weshalb die Prüfung argc < 2 beim ersten Lauf greift und weshalb es sich lohnt, sie zu schreiben.

Häufige Fehler

argv[1] lesen, ohne argc zu prüfen. Undefiniertes Verhalten, wenn keine Argumente übergeben wurden - und der häufigste Absturz in diesem Bereich.
Die Schleife bei i = 0 beginnen. Das verarbeitet den Programmnamen, als wäre er ein Datum.
argv[1] als Zahl behandeln. Es ist Text, bis du es umwandelst.
atoi auf Benutzereingaben anwenden. Kein Weg, ein schlechtes Argument von einer Null zu unterscheiden.
Zeichenketten mit == vergleichen. Nimm strcmp.
In die argv-Zeichenketten schreiben. Sie zu verändern ist vom Standard erlaubt, aber der Platz ist begrenzt und plattformabhängig; kopiere in deinen eigenen Puffer, wenn du etwas ändern musst.

Häufig gestellte Fragen

Was sind argc und argv in C?

Sie sind die beiden Parameter von int main(int argc, char *argv[]). argc ist die Anzahl der Kommandozeilenargumente einschließlich des Programmnamens; argv ist ein Array dieser Argumente als Zeichenketten. argv[0] ist der Programmname, argv[1] das erste echte Argument, und argv[argc] ist immer NULL.

Wie übergibt man einem C-Programm Argumente?

Tippe sie im Terminal hinter den Namen der ausführbaren Datei: ./program hallo 42. Das ergibt argc == 3, mit argv[1] als Zeichenkette "hallo" und argv[2] als "42". Im Editor auf dieser Seite gehören die Argumente stattdessen in das Args-Feld.

Wie wandelt man ein Kommandozeilenargument in C in ein int um?

Benutze strtol: char *end; long n = strtol(argv[1], &end, 10); und prüfe dann, dass end nicht noch am Anfang steht (nichts gelesen) und dass *end gleich '\0' ist (kein Rest). atoi ist kürzer, liefert aber 0 sowohl für "0" als auch für "banane" und kann daher keinen Fehler melden.

Was ist argv[0] in C?

Der Name, mit dem das Programm aufgerufen wurde - typischerweise ./program oder der volle Pfad. Er ist nützlich in Benutzungshinweisen (fprintf(stderr, "Aufruf: %s DATEI\n", argv[0])), damit die Meldung dazu passt, wie der Benutzer es tatsächlich aufgerufen hat. In ungewöhnlichen Fällen kann er eine leere Zeichenkette sein, nimm also nicht an, dass er da ist.

Verwandte Konzepte