Was bedeutet int argc, char * argv []?

In vielen C ++ - IDEs und Compilern sieht es folgendermaßen aus, wenn die Hauptfunktion für Sie generiert wird:

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

Wenn ich C ++ ohne IDE nur mit einem Befehlszeilen-Compiler codiere, gebe ich Folgendes ein:

int main()

ohne Parameter. Was bedeutet das und ist es für mein Programm von entscheidender Bedeutung?

argvund argcwie Befehlszeilenargumente main()in C und C ++ übergeben werden.

argcwird die Anzahl der Zeichenfolgen sein, auf die durch gezeigt wird argv. Dies ist (in der Praxis) 1 plus die Anzahl der Argumente, da praktisch alle Implementierungen dem Array den Namen des Programms voranstellen.

Die Variablen werden gemäß Konvention argc( Argumentanzahl ) und argv( Argumentvektor ) benannt, können jedoch mit jedem gültigen Bezeichner versehen werden: int main(int num_args, char** arg_strings)ist gleichermaßen gültig.

Sie können auch ganz weggelassen werden int main(), wenn Sie keine Befehlszeilenargumente verarbeiten möchten.

Versuchen Sie das folgende Programm:

#include <iostream>

int main(int argc, char** argv) {
    std::cout << "Have " << argc << " arguments:" << std::endl;
    for (int i = 0; i < argc; ++i) {
        std::cout << argv[i] << std::endl;
    }
}

Wenn Sie es mit ausführen, ./test a1 b2 c3wird ausgegeben

Have 4 arguments:
./test
a1
b2
c3

argcist die Anzahl der Argumente, die über die Befehlszeile an Ihr Programm übergeben werden, und argvdas Array der Argumente.

Sie können die Argumente durchlaufen, indem Sie die Anzahl der Argumente kennen:

for(int i = 0; i < argc; i++)
{
    // argv[i] is the argument at index i
}

Angenommen, Sie führen Ihr Programm folgendermaßen aus (unter Verwendung der shSyntax):

myprog arg1 arg2 'arg 3'

Wenn Sie Ihre Hauptleitung als deklariert haben, wird Ihre int main(int argc, char *argv[])(in den meisten Umgebungen) main()wie folgt aufgerufen:

p = { "myprog", "arg1", "arg2", "arg 3", NULL };
exit(main(4, p));

Wenn Sie jedoch Ihr Haupt als deklariert haben int main(), wird es so etwas wie genannt

exit(main());

und Sie bekommen die Argumente nicht übergeben.

Zwei zusätzliche Dinge zu beachten:

1. Dies sind die einzigen zwei Standard-Signaturen für main. Wenn eine bestimmte Plattform zusätzliche Argumente oder einen anderen Rückgabetyp akzeptiert, ist dies eine Erweiterung und sollte in einem portablen Programm nicht verwendet werden.
2. *argv[]und **argvsind genau gleichwertig, so dass Sie schreiben können int main(int argc, char *argv[])als int main(int argc, char **argv).

Die Parameter zur mainDarstellung der Befehlszeilenparameter, die dem Programm beim Start zur Verfügung gestellt wurden. Der argcParameter stellt die Anzahl der Befehlszeilenargumente dar und char *argv[]ist ein Array von Zeichenfolgen (Zeichenzeigern), die die einzelnen Argumente in der Befehlszeile darstellen.

Die mainFunktion kann zwei Parameter haben, argcund argv. argcist ein integer ( int) -Parameter und die Anzahl der an das Programm übergebenen Argumente.

Der Programmname ist immer das erste Argument, daher gibt es mindestens ein Argument für ein Programm und der Mindestwert von argcist eins. Wenn ein Programm selbst zwei Argumente hat, ist der Wert von argcdrei.

Der Parameter argvzeigt auf ein String-Array und wird als Argumentvektor bezeichnet . Es ist ein eindimensionales String-Array von Funktionsargumenten.

int main();

Dies ist eine einfache Erklärung. Es können keine Befehlszeilenargumente akzeptiert werden.

int main(int argc, char* argv[]);

Diese Deklaration wird verwendet, wenn Ihr Programm Befehlszeilenargumente annehmen muss. Wenn Sie so laufen:

myprogram arg1 arg2 arg3

argc, oder Argument Count wird auf 4 (vier Argumente) gesetzt, und argvoder Argument Vectors werden mit Zeichenfolgenzeigern auf "myprogram", "arg1", "arg2" und "arg3" gefüllt. Der Programmaufruf ( myprogram) ist in den Argumenten enthalten!

Alternativ können Sie Folgendes verwenden:

int main(int argc, char** argv);

Dies gilt auch.

Es gibt einen weiteren Parameter, den Sie hinzufügen können:

int main (int argc, char *argv[], char *envp[])

Der envpParameter enthält auch Umgebungsvariablen. Jeder Eintrag folgt diesem Format:

VARIABLENAME=VariableValue

so was:

SHELL=/bin/bash    

Die Liste der Umgebungsvariablen ist nullterminiert.

WICHTIG: Verwenden Sie KEINE argvoder envpWerte direkt in Aufrufen von system()! Dies ist eine große Sicherheitslücke, da böswillige Benutzer Umgebungsvariablen auf Befehlszeilenbefehle setzen und (möglicherweise) massiven Schaden anrichten können. Im Allgemeinen nur nicht verwenden system(). Es gibt fast immer eine bessere Lösung, die durch C-Bibliotheken implementiert wird.

Der erste Parameter ist die Anzahl der bereitgestellten Argumente und der zweite Parameter ist eine Liste von Zeichenfolgen, die diese Argumente darstellen.

Beide von

int main(int argc, char *argv[]);
int main();

sind rechtliche Definitionen des Einstiegspunkts für ein C- oder C ++ - Programm. Stroustrup: In den häufig gestellten Fragen zu Stil und Technik von C ++ werden einige der Variationen aufgeführt, die für Ihre Hauptfunktion möglich oder zulässig sind.