web-dev-qa-db-ger.com

Was bedeutet int argc, char * argv []?

In vielen C++ - IDEs und -Compilern sieht es beim Generieren der Hauptfunktion folgendermaßen aus:

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

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

int main()

ohne Parameter. Was bedeutet das und ist es wichtig für mein Programm?

c++parameterscommand-line-argumentsargvargc
464
Greg Treleaven

argv und argc geben an, wie Befehlszeilenargumente in C und C++ an main() übergeben werden.

argc ist die Anzahl der Zeichenfolgen, auf die argv zeigt. Dies wird (in der Praxis) 1 plus der Anzahl der Argumente sein, da bei praktisch allen Implementierungen der Name des Programms dem Array vorangestellt wird.

Die Variablen haben die Bezeichnungen argc (Argumentanzahl) und argv (Argumentvektor). Sie können jedoch mit einem beliebigen gültigen Bezeichner versehen werden: int main(int num_args, char** arg_strings) ist gleichermaßen gültig.

Sie können auch vollständig weggelassen werden und ergeben int main(), wenn Sie keine Befehlszeilenargumente verarbeiten möchten.

Versuchen Sie folgendes 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 ./test a1 b2 c3 ausführen, wird es ausgegeben

Have 4 arguments:
./test
a1
b2
c3
597
meagar

argc ist die Anzahl der Argumente, die von der Befehlszeile an Ihr Programm übergeben werden, und argv ist das 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
}
50
John Boker

Angenommen, Sie führen Ihr Programm folgendermaßen aus (mit der sh -Syntax):

myprog arg1 arg2 'arg 3'

Wenn Sie Ihr main als int main(int argc, char *argv[]) deklariert haben, wird (in den meisten Umgebungen) Ihr main() folgendermaßen aufgerufen:

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

Wenn Sie jedoch Ihr main als int main() deklariert haben, heißt es so etwas wie

exit(main());

und Sie bekommen die Argumente nicht weitergegeben.

Zwei zusätzliche Dinge zu beachten:

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

Die Parameter für main stellen die Befehlszeilenparameter dar, die dem Programm beim Start zur Verfügung gestellt wurden. Der Parameter argc steht für die Anzahl der Befehlszeilenargumente, und char *argv[] ist ein Array von Zeichenfolgen (Zeichenzeiger), die die einzelnen in der Befehlszeile angegebenen Argumente darstellen.

8
BlueMonkMN

Die Funktion main kann zwei Parameter haben, argc und argv. argc ist ein ganzzahliger Parameter (int) und gibt die Anzahl der an das Programm übergebenen Argumente an.

Der Programmname ist immer das erste Argument. Es gibt also mindestens ein Argument für ein Programm, und der Mindestwert von argc ist eins. Wenn sich ein Programm jedoch aus zwei Argumenten zusammensetzt, beträgt der Wert von argc drei.

Der Parameter argv zeigt auf ein String-Array und heißt Argumentvektor. Es ist ein eindimensionales String-Array von Funktionsargumenten.

5
moshtagh

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

4
Nick Gerakines
int main();

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

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

Diese Deklaration wird verwendet, wenn Ihr Programm Befehlszeilenargumente verwenden muss. Wenn Sie wie folgt laufen:

myprogram arg1 arg2 arg3

argc oder Argument Count wird auf 4 (vier Argumente) gesetzt, und argv oder Argument Vectors werden mit String-Zeigern auf "myprogram", "arg1", "arg2", und "arg3". 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 Parameter envp 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 argv oder envp Werte 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. Verwenden Sie im Allgemeinen einfach nicht system(). Es gibt fast immer eine bessere Lösung, die durch C-Bibliotheken implementiert wird.

4
Adrian Zhang

Beide von

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

sind rechtliche Definitionen des Einstiegspunkts für ein C- oder C++ - Programm. Stroustrup: C++ - FAQ zu Stil und Technik beschreibt einige der Variationen, die für Ihre Hauptfunktion möglich oder zulässig sind.

1
Chris Becke