Umgang mit Befehlszeilen-Flags in C/C++

Lesezeit: 6 Minuten

Benutzer-Avatar
Fabio Gómez

Ich suche nach einer sehr einfachen Erklärung / Anleitung, was Flags sind. Ich verstehe, dass Flags funktionieren und einen Befehl angeben, was zu tun ist. Zum Beispiel:

rm -Rf test

Ich weiß, dass der Befehl rm den Testordner entfernt und dass die Flags -Rf den Befehl dazu zwingen, nicht nur den Ordner, sondern auch die darin enthaltenen Dateien zu löschen.

Aber wo werden die Flags gelesen/kompiliert??? Was behandelt die Flaggen? Kann ich zum Beispiel mein eigenes C/C++-Programm schreiben und unterschiedliche Flags zuweisen, damit das Programm unterschiedliche Dinge tut? Ich hoffe, ich stelle die richtigen Fragen. Wenn nicht, lassen Sie es mich bitte wissen.

Benutzer-Avatar
zwöl

Auf der C-Ebene erscheinen Befehlszeilenargumente für ein Programm in den Parametern für die main Funktion. Wenn Sie beispielsweise dieses Programm kompilieren:

#include <stdio.h>
int main(int argc, char **argv)
{
    int i;
    for (i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);
    return 0;
 }

und rufen Sie es mit den gleichen Argumenten wie Ihr Beispielbefehl ‘rm’ auf, Sie erhalten Folgendes:

$ ./a.out -Rf test
argv[0] = ./a.out
argv[1] = -Rf
argv[2] = test

Wie Sie sehen können, ist der erste Eintrag in argv ist der Name des Programms selbst, und die restlichen Array-Einträge sind die Befehlszeilenargumente.

Das Betriebssystem kümmert sich überhaupt nicht um die Argumente; es liegt an Ihrem Programm, sie zu interpretieren. Es gibt jedoch Konventionen für ihre Funktionsweise, von denen die folgenden die wichtigsten sind:

  • Argumente sind unterteilt in Optionen und Nicht-Optionen. Optionen beginnen mit einem Bindestrich, Nicht-Optionen nicht.
  • Optionen sollen, wie der Name schon sagt, sein Optional. Wenn Ihr Programm einige Befehlszeilenargumente benötigt, um irgendetwas Nützliches zu tun, sollten diese Argumente keine Optionen sein (dh sie sollten nicht mit einem Bindestrich beginnen).
  • Optionen können weiter unterteilt werden in kurz Optionen, die aus einem einzelnen Bindestrich gefolgt von einem einzelnen Buchstaben bestehen (-r, -f), und lang Optionen, bei denen es sich um zwei Bindestriche gefolgt von einem oder mehreren durch Bindestriche getrennten Wörtern (--recursive, --frobnicate-the-gourds). Kurze Optionen können zu einem Argument zusammengefasst werden (-rf), solange keiner von ihnen Argumente akzeptiert (siehe unten).
  • Optionen können selbst Argumente annehmen.
    • Das Argument zu a kurz Möglichkeit -x ist entweder der Rest der argv Eintrag, oder wenn in diesem Eintrag kein weiterer Text steht, gleich der nächste argv Eintrag ob oder nicht es beginnt mit einem Bindestrich.
    • Das Argument zu a lang Option wird mit einem Gleichheitszeichen abgesetzt: --output=outputfile.txt.
  • Wenn irgend möglich, sollte die relative Reihenfolge verschiedener Optionen (mit ihren Argumenten) keinen beobachtbaren Effekt haben.
  • Die besondere Option -- bedeutet “behandeln Sie nichts nach diesem Punkt in der Befehlszeile als Option, auch wenn es so aussieht.” So können Sie beispielsweise eine Datei mit dem Namen „-f‘ durch Eingabe von rm -- -f.
  • Die besondere Option - bedeutet “Standardeingabe lesen”.
  • Es gibt eine Reihe von kurzen Optionsbuchstaben, die per Konvention reserviert sind: Die wichtigsten sind
    • -v = ausführlich sein
    • -q = still sein
    • -h = einen Hilfetext drucken
    • -o Datei = Ausgang zu Datei
    • -f = erzwingen (nicht zur Bestätigung gefährlicher Aktionen auffordern, sondern einfach ausführen)

Es gibt eine Reihe von Bibliotheken, die Ihnen beim Analysieren von Befehlszeilenargumenten helfen. Das tragbarste, aber auch das eingeschränkteste davon ist getopt, das heutzutage auf den meisten Systemen in die C-Bibliothek eingebaut ist. Ich empfehle Ihnen, die gesamte Dokumentation für zu lesen GNU-argp auch wenn Sie dieses spezielle nicht verwenden möchten, da es Sie in den Konventionen weiterbilden wird.

Es ist auch erwähnenswert, dass die Wildcard-Erweiterung (rm -rf *) erledigt Vor Ihr Programm wird jemals aufgerufen. Wenn Sie das obige Beispielprogramm als ausgeführt haben ./a.out * in einem Verzeichnis, das nur die Binärdatei und ihren Quellcode enthält, würden Sie erhalten

argv[0] = ./a.out
argv[1] = a.out
argv[2] = test.c

  • Fantastische Beschreibung! Vielen Dank.

    – Jan

    28. April 2021 um 0:23 Uhr

Benutzer-Avatar
abelenki

Dieses einfache Programm sollte die an das Programm übergebenen Argumente demonstrieren (einschließlich des Programmnamens selbst).

Das Analysieren, Interpretieren und Verwenden dieser Argumente ist Sache des Programmierers (Sie), obwohl Bibliotheken zur Verfügung stehen, die Ihnen helfen:

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

Wenn Sie dieses Programm in a.outund führen Sie es aus als:

prompt$>  ./a.out ParamOne ParamTwo -rf x.c

Sie sollten die Ausgabe sehen:

Argument 0 : a.out
Argument 1 : ParamOne
Argument 2 : ParamTwo
Argument 3 : -rf
Argument 4 : x.c

Benutzer-Avatar
Xenogenese

Tatsächlich können Sie Ihr eigenes C++-Programm schreiben, das Befehlszeilenparameter wie diese akzeptiert:

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

Die Variable argc enthält die Anzahl der Parameter, während char* die Parameter selbst enthält.

Sie können die Parameter wie folgt versenden:

for (int i = 1; i < argc; i++)
{  
    if (i + 1 != argc)
    {
        if (strcmp(argv[i], "-filename") == 0) // This is your parameter name
        {                 
            char* filename = argv[i + 1];    // The next value in the array is your value
            i++;    // Move to the next flag
        }
    }
}

  • In Zeile 3 vergleichen Sie Zeiger, keine Zeichenfolgen … Es sollte eher sein: if ( strcmp( argc[i], "-filename") == 0) {

    – Kamil S Jaron

    27. März 2016 um 17:52 Uhr

In Ihrem eigenen C-Programm können Sie Befehlszeilenoptionen beliebig verarbeiten. Befehlszeilenparameter in C kommen in den Parametern von main(int argc, char *argv[])-Methode als Zeichenfolgen.

Und wenn Sie Befehlszeilenparameter ähnlich wie die meisten UNIX-Befehle verarbeiten möchten, ist die Funktion, nach der Sie wahrscheinlich suchen, wahrscheinlich getopt()

Viel Glück!

Am einfachsten ist es, Ihre zu schreiben main() so:

int main(int argc, char* argv[]) { …

Dann in dieser Hauptleitung Sie entscheiden, was mit den Befehlszeilenargumenten oder “Flags” passiert. Sie finden sie in argv und ihre Nummer ist argc.

Benutzer-Avatar
75-Zoll-Pianist

Flags sind Argumente, die an den Haupteinstiegspunkt des Programms übergeben werden. Beispielsweise können Sie in einem C++-Programm haben

int main(int arc, char* argv[]){
return 0;
}

Ihr Bogen ist die Anzahl der übergebenen Argumente, und der Zeiger gibt Ihnen die Liste der tatsächlichen Argumente. so für

rm -Rf test

argc wäre 3 und das argv-Array würde Ihre Argumente enthalten. Beachten Sie argc >= 1, weil der Programmname selbst zählt (rm). -RF ist Ihr zweiter Parameter und Test ist Ihr dritter.

Wenn Sie also Befehle in Unix eingeben, führen Sie im Wesentlichen Programme aus und übergeben ihnen Parameter, mit denen sie arbeiten.

Wenn Sie wirklich WIRKLICH am Unix-Betriebssystem interessiert sind, sollten Sie nach Forks und ihrer Funktionsweise suchen. Dies kann für einen Neuling jedoch ziemlich verwirrend werden, also nur, wenn Sie sich wirklich für das Betriebssystem und die Ausführung von Programmen interessieren.

Benutzer-Avatar
Michael Conlen

GNU libc, die sehr wahrscheinlich auf Ihrem System verfügbar ist, hat dafür eine Bibliothek namens getopt, die verwendet werden kann, um die Optionen auf vernünftige Weise zu parsen. Beispiele für den Einstieg finden Sie in der unten verlinkten Dokumentation.

http://www.gnu.org/software/libc/manual/html_node/Getopt.html#Getopt

1216370cookie-checkUmgang mit Befehlszeilen-Flags in C/C++

This website is using cookies to improve the user-friendliness. You agree by using the website further.

Privacy policy