main Funktions- und Befehlszeilenargumente

Alle C++-Programme müssen über eine Funktion main verfügen. Wenn Sie versuchen, ein C++-Programm ohne Funktion zu main kompilieren, löst der Compiler einen Fehler aus. (Dynamic Link-Bibliotheken static und Bibliotheken verfügen nicht über eine main Funktion.) Die Funktion ist der Ort, an dem der Quellcode mit der Ausführung beginnt, aber bevor ein Programm in die Funktion eintritt, werden alle Klassenmitglieder ohne explizite Initialisierer main main auf static 0 (null) festgelegt. In Microsoft C++ werden globale static Objekte auch vor dem Eintrag in initialisiert. main Für die Funktion gelten mehrere main Einschränkungen, die nicht für andere C++-Funktionen gelten. Mit der Funktion main werden folgende Aktionen ausgeführt:

  • Kann nicht überladen werden (siehe Funktionsüberladung).
  • Kann nicht als deklariert inline werden.
  • Kann nicht als deklariert static werden.
  • Die Adresse kann nicht übernommen werden.
  • Kann nicht von Ihrem Programm aufgerufen werden.

Die main Funktionssignatur

Die main Funktion hat keine Deklaration, da sie in die Sprache integriert ist. Wenn dies der Fall wäre, würde die main Deklarationssyntax für wie die folgende aussehen:

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

Wenn kein Rückgabewert in angegeben main ist, stellt der Compiler den Rückgabewert 0 (null) zur Angabe.

Standardbefehlszeilenargumente

Die Argumente für main ermöglichen eine praktische Befehlszeilen-Analyse von Argumenten. Die Typen für argc und argv werden von der Programmiersprache definiert. Die Namen argc und argv sind traditionell, aber Sie können sie nach Benamen benennen.

Die Argumentdefinitionen sind wie folgt:

argc
Eine ganze Zahl, die die Anzahl der Argumente enthält, die in argv folgen. Der argc -Parameter ist immer größer oder gleich 1.

argv
Ein Array von Zeigern auf Zeichenfolgen, die auf NULL enden und von den Benutzern des Programms eingegebene Befehlszeilenargumente darstellen. Standardmäßig ist argv[0] der Befehl, mit dem das Programm aufgerufen wird. argv[1] ist das erste Befehlszeilenargument. Das letzte Argument in der Befehlszeile ist argv[argc - 1] , und ist immer argv[argc] NULL.

Informationen zum Unterdrücken der Befehlszeilenverarbeitung finden Sie unter Anpassen der C++-Befehlszeilenverarbeitung.

Hinweis

Standardmäßig ist argv[0] der Dateiname des Programms. Auf der Windows ist es jedoch möglich, einen Prozess mithilfe von zu CreateProcess erhalten. Wenn Sie sowohl das erste als auch das zweite Argument ( lpApplicationName und lpCommandLine ) argv[0] verwenden, ist möglicherweise nicht der Name der ausführbaren Datei. Sie können GetModuleFileName verwenden, um den Namen der ausführbaren Datei und ihren vollqualifizierten Pfad abzurufen.

Microsoft-spezifische Erweiterungen

In den folgenden Abschnitten wird das Microsoft-spezifische Verhalten beschrieben.

Die wmain Funktion und das _tmain Makro

Wenn Sie Ihren Quellcode so entwerfen, dass unicodeweite Acter verwendet werden, können Sie den Microsoft-spezifischen Einstiegspunkt verwenden, bei dem es sich um die char wmain Breitzeichenversion von char main handelt. Dies ist die effektive Deklarationssyntax für wmain :

int wmain();
int wmain(int argc, wchar_t *argv[]);

Sie können auch das Microsoft-spezifische _tmain verwenden, bei dem es sich um ein in definiertes Präprozessormakro tchar.h handelt. _tmain löst in main auf, es sei _UNICODE denn, ist definiert. In diesem Fall wird _tmain in wmain aufgelöst. Das Makro und andere Makros, die mit beginnen, sind nützlich für Code, der separate Versionen für schmale und _tmain _t breite char Sätze erstellen muss. Weitere Informationen finden Sie unter Verwenden von Zuordnungen mit generischem Text.

Rückgabe void von main

Als Microsoft-Erweiterung können die Funktionen und als Rückgabe main wmain deklariert werden void (kein Rückgabewert). Diese Erweiterung ist auch in einigen anderen Compilern verfügbar, ihre Verwendung wird jedoch nicht empfohlen. Sie ist für die Symmetrie verfügbar, main wenn keinen Wert zurück gibt.

Wenn Sie oder als zurückgeben, können Sie keinen Code an den übergeordneten Prozess oder das Betriebssystem zurückgeben, main wmain indem Sie eine void exit -Anweisung return verwenden. Um einen Code exit zurück zu geben, main wenn oder als deklariert wmain void ist, müssen Sie die -Funktion exit verwenden.

Das envp Befehlszeilenargument

Die main wmain Signaturen oder ermöglichen eine optionale Microsoft-spezifische Erweiterung für den Zugriff auf Umgebungsvariablen. Diese Erweiterung wird auch in anderen Compilern für Windows und UNIX verwendet. Der Name envp ist traditionell, aber Sie können den Umgebungsparameter nach Bennen benennen. Dies sind die effektiven Deklarationen für die Argumentlisten, die den Umgebungsparameter enthalten:

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

envp
Der envp optionale Parameter ist ein Array von Zeichenfolgen, die die in der Umgebung des Benutzers festgelegten Variablen darstellen. Das Array wird mit einem NULL-Eintrag beendet. Sie kann als Array von Zeigern auf ( ) oder als Zeiger auf Zeiger char auf ( ) deklariert char *envp[] char char **envp werden. Wenn ihr Programm wmain anstelle von main verwendet, verwenden Sie den Datentyp anstelle wchar_t von char .

Der an übergebene main Umgebungsblock wmain ist eine "fixierte" Kopie der aktuellen Umgebung. Wenn Sie die Umgebung später ändern, indem Sie oder aufrufen, ändert sich die aktuelle Umgebung (wie von oder und der Variablen oder zurückgegeben), aber der Block, auf den zeigt, ändert sich putenv _wputenv getenv _wgetenv _environ _wenviron envp nicht. Weitere Informationen zum Unterdrücken der Umgebungsverarbeitung finden Sie unter Anpassen der C++-Befehlszeilenverarbeitung. Das envp Argument ist mit dem C89-Standard kompatibel, aber nicht mit C++-Standards.

Beispielargumente für main

Das folgende Beispiel zeigt, wie die Argumente argc , und für verwendet argv envp main werden:

// argument_definitions.cpp
// compile with: /EHsc
#include <iostream>
#include <string.h>

using namespace std;
int main( int argc, char *argv[], char *envp[] )
{
    bool numberLines = false;    // Default is no line numbers.

    // If /n is passed to the .exe, display numbered listing
    // of environment variables.
    if ( (argc == 2) && _stricmp( argv[1], "/n" ) == 0 )
         numberLines = true;

    // Walk through list of strings until a NULL is encountered.
    for ( int i = 0; envp[i] != NULL; ++i )
    {
        if ( numberLines )
            cout << i << ": "; // Prefix with numbers if /n specified
        cout << envp[i] << "\n";
    }
}

Analysieren von C++-Befehlszeilenargumenten

Die vom Microsoft C/C++-Code verwendeten Befehlszeilen-Analyseregeln sind Microsoft-spezifisch. Der Laufzeitstartcode verwendet diese Regeln beim Interpretieren von Argumenten, die in der Betriebssystembefehlszeile angegeben werden:

  • Argumente werden durch einen Leerraum (Leerzeichen oder Tabstopp) abgegrenzt.

  • Das erste Argument (argv[0]) wird besonders behandelt. Es repräsentiert den Programmnamen. Da es sich um einen gültigen Pfadnamen handeln muss, sind Bestandteile in doppelten geraden Anführungszeichen oben ( " ) zulässig. Die Anführungszeichen sind nicht in der Ausgabe von argv[0] enthalten. Die von doppelten Anführungszeichen umgebenen Teile verhindern die Interpretation eines Leerzeichens oder Tabstoppzeichens als char Ende des Arguments. Die weiter unten in dieser Liste aufgeführten Regeln gelten nicht.

  • Eine Zeichenfolge, die von doppelten Anführungszeichen umgeben ist, wird als einzelnes Argument interpretiert, das Leerzeichen enthalten char kann. Eine Zeichenfolge in Anführungszeichen kann in ein Argument eingebettet sein. Das Caretzeichen ( ) wird nicht als Escapezeichen ^ char oder Trennzeichen erkannt. Innerhalb einer in Anführungszeichen eingeschlossenen Zeichenfolge wird ein Paar aus doppelten Anführungszeichen als ein einzelnes doppeltes Anführungszeichen mit Escapezeichen interpretiert. Wenn die Befehlszeile endet, bevor eine schließende doppelte Anführungszeichen gefunden wird, werden alle bisher gelesenen Akters char als letztes Argument ausgegeben.

  • Wenn dem doppelten Anführungszeichen ein umgekehrter Schrägstrich ( \" ) vorangestellt ist, wird diese Zeichenfolge als tatsächliches doppeltes Anführungszeichen ( " ) interpretiert.

  • Ein umgekehrter Schrägstrich wird als solcher interpretiert, sofern er nicht unmittelbar vor einem Anführungszeichen steht.

  • Wenn ein doppeltes Anführungszeichen auf eine gerade Anzahl umgekehrter Schrägstriche folgt, wird für jedes Paar umgekehrter Schrägstriche ( \\ ) ein umgekehrter Schrägstrich ( \ ) im argv-Array platziert. Das doppelte Anführungszeichen ( " ) wird als Zeichenfolgentrennzeichen interpretiert.

  • Wenn ein doppeltes Anführungszeichen auf eine ungerade Anzahl umgekehrter Schrägstriche folgt, wird für jedes Paar umgekehrter Schrägstriche ( \\ ) ein umgekehrter Schrägstrich ( \ ) im argv-Array platziert. Die doppelte Anführungszeichen werden als Escapesequenz durch den ing-ing-schrägen Schrägstrich interpretiert, sodass eine literale doppelte main Anführungszeichen ( " ) in platziert argv wird.

Beispiel für die Analyse von Befehlszeilenargumenten

Das folgende Programm zeigt, wie Befehlszeilenargumente übergeben werden:

// command_line_arguments.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
int main( int argc,      // Number of strings in array argv
          char *argv[],   // Array of command-line argument strings
          char *envp[] )  // Array of environment variable strings
{
    int count;

    // Display each command-line argument.
    cout << "\nCommand-line arguments:\n";
    for( count = 0; count < argc; count++ )
         cout << "  argv[" << count << "]   "
                << argv[count] << "\n";
}

Ergebnisse der Analyse von Befehlszeilen

Die folgende Tabelle zeigt beispielhafte Eingaben und zu erwartende Ausgaben, wobei die Regeln in der vorangehenden Liste aufgezeigt werden.

Befehlszeileneingabe argv[1] argv[2] argv[3]
"abc" d e abc d e
a\\b d"e f"g h a\\b de fg h
a\\\"b c d a\"b c d
a\\\\"b c" d e a\\b c d e
a"b"" c d ab" c d

Platzhaltererweiterung

Mit dem Microsoft-Compiler können Sie optional Platzhalter, das Fragezeichen ( ) und das Sternchen ( ) verwenden, um Dateinamen- und Pfadargumente in der char Befehlszeile ? * anzugeben.

Befehlszeilenargumente werden von einer internen Routine im Laufzeitstartcode behandelt, die Platzhalter standardmäßig nicht in separate Zeichenfolgen im argv Zeichenfolgenarray erweitert. Sie können die Platzhaltererweiterung aktivieren, indem Sie die Datei ( Datei für ) in Ihre setargv.obj wsetargv.obj wmain /link Compileroptionen oder die LINK Befehlszeile ein.

Weitere Informationen zu den Optionen für den Runtimestartlinker finden Sie unter Linkoptionen.

Anpassen der C++-Befehlszeilenverarbeitung

Wenn das Programm keine Befehlszeilenargumente akzeptiert, können Sie die Routine zur Befehlszeilenverarbeitung unterdrücken, um ein wenig Speicherplatz zu sparen. Um ihre Verwendung zu unterdrücken, schließen Sie die noarg.obj -Datei (sowohl für main als auch für wmain) in Ihre /link -Compileroptionen oder LINK -Befehlszeile ein.

Ebenso können Sie die interne Routine zur Umgebungsverarbeitung unterdrücken, wenn Sie nie über das envp -Argument auf die Umgebungstabelle zugreifen. Um ihre Verwendung zu unterdrücken, schließen Sie die noenv.obj -Datei (sowohl für main als auch für wmain) in Ihre /link -Compileroptionen oder LINK -Befehlszeile ein.

Das Programm ruft möglicherweise die spawn- oder exec-Gruppe von Routinen in der C-Laufzeitbibliothek auf. Wenn dies der Fall ist, sollten Sie die Routine zur Umgebungsverarbeitung nicht unterdrücken, da diese Routine verwendet wird, um eine Umgebung aus dem übergeordneten Prozess an den untergeordneten Prozess zu übergeben.

Weitere Informationen

Grundlegende Konzepte