main Funktions- und Befehlszeilenargumente

Alle C++-Programme müssen über eine main Funktion verfügen. Wenn Sie versuchen, ein C++-Programm ohne Funktion main zu kompilieren, löst der Compiler einen Fehler aus. (Dynamische Verknüpfungsbibliotheken und static Bibliotheken verfügen nicht über eine main Funktion.) Die main Funktion ist der Ort, an dem der Quellcode mit der Ausführung beginnt, aber bevor ein Programm die main Funktion eingibt, werden alle static Klassenelemente ohne explizite Initialisierungen auf Null festgelegt. In Microsoft C++ werden globale static Objekte ebenfalls initialisiert, bevor Sie den Eintrag eingeben main. Es gelten mehrere Einschränkungen für die main Funktion, die nicht auf andere C++-Funktionen angewendet wird. Mit der Funktion main werden folgende Aktionen ausgeführt:

  • Kann nicht überladen werden (siehe Funktionsüberladung).
  • Kann nicht als inlinedeklariert werden.
  • Kann nicht als staticdeklariert werden.
  • Die Adresse kann nicht ausgeführt werden.
  • Sie können nicht aus Ihrem Programm aufgerufen werden.

Die main Funktionssignatur

Die main Funktion verfügt nicht über eine Deklaration, da sie in die Sprache integriert ist. Wenn dies der Fall ist, würde die Deklarationssyntax main wie folgt aussehen:

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

Wenn kein Rückgabewert in mainangegeben ist, liefert der Compiler einen Rückgabewert von Null.

Standardmäßige Befehlszeilenargumente

Die Argumente für main die bequeme Befehlszeilenanalyse 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 benennen, was Sie mögen.

Die Argumentdefinitionen sind wie folgt:

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

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

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

Hinweis

In der Konvention argv[0] ist der Dateiname des Programms. Bei Windows ist es jedoch möglich, einen Prozess mithilfe CreateProcesseines Prozesses zu spawnen. Wenn Sie sowohl die ersten als auch die zweiten Argumente (lpApplicationName und lpCommandLine) verwenden, argv[0] ist möglicherweise nicht der ausführbare Name. Sie können GetModuleFileName den ausführbaren Namen und den vollqualifizierten Pfad abrufen.

Microsoft-spezifische Erweiterungen

In den folgenden Abschnitten werden das microsoftspezifische Verhalten beschrieben.

Die wmain Funktion und _tmain das Makro

Wenn Sie Ihren Quellcode so entwerfen, dass unicodeweite charAkte verwendet werden, können Sie den Microsoft-spezifischen wmain Einstiegspunkt verwenden, der die Breitakterversionchar von main. Dies ist die effektive Deklarationssyntax für wmain:

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

Sie können auch das microsoftspezifische _tmainMakro verwenden, das ein Präprozessormakro ist, das in tchar.h. _tmain wird aufgelöst, main es sei denn _UNICODE , es ist definiert. In diesem Fall wird _tmain in wmain aufgelöst. Das _tmain Makro und andere Makros, die beginnen _t , sind nützlich für Code, der separate Versionen sowohl für schmale als auch breite charAktierersätze erstellen muss. Weitere Informationen finden Sie unter Verwenden von generischen Textzuordnungen.

void Zurückgeben vonmain

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

Wenn Sie einen Code oder als Rückgabe deklarieren main oder wmain zurückgeben void, können Sie keinen exit Code an den übergeordneten Prozess oder das Betriebssystem zurückgeben, indem Sie eine return Anweisung verwenden. Um einen exit Code zurückzugeben, wenn main oder wmain als voiddeklariert wird, müssen Sie die exit Funktion verwenden.

Das envp Befehlszeilenargument

Die main Signaturen wmain ermöglichen eine optionale microsoftspezifische Erweiterung für den Zugriff auf Umgebungsvariablen. Diese Erweiterung ist auch in anderen Compilern für Windows und UNIX Systeme üblich. Der Name envp ist traditionell, aber Sie können den Umgebungsparameter benennen, was Sie mögen. Hier 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 optionale envp Parameter ist ein Array von Zeichenfolgen, das die Variablen darstellt, die in der Umgebung des Benutzers festgelegt sind. Das Array wird mit einem NULL-Eintrag beendet. Es kann als Array von Zeigern auf char () oder als Zeiger char auf (char *envp[]char **envp) deklariert werden. Wenn Ihr Programm wmain anstelle des mainDatentyps verwendet wird, verwenden Sie wchar_t den Datentyp anstelle von char.

Der an die Umgebung übergebene main Umgebungsblock ist wmain eine "fixierte" Kopie der aktuellen Umgebung. Wenn Sie die Umgebung später ändern, indem Sie einen Aufruf oder einen Aufruf putenv_wputenvvornehmen, ändert sich die aktuelle Umgebung (wie zurückgegeben durch getenv oder _wgetenv und die _environ_wenviron Variable), aber der Block, der envp darauf verweist, ändert sich 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 Sie die argcargvArgumente und envp Argumente verwenden:main

// 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 von Microsoft C/C++-Code verwendeten Befehlszeilenanalyseregeln sind microsoftspezifisch. Der Laufzeitstartcode verwendet diese Regeln beim Interpretieren von Argumenten auf der Befehlszeile des Betriebssystems:

  • 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 Teile, die durch doppelte Anführungszeichen umgeben sind, verhindern die Interpretation eines Leerzeichens oder tabstopps charals 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-Acter charenthalten kann. Eine Zeichenfolge in Anführungszeichen kann in ein Argument eingebettet sein. Der Caret (^) wird nicht als Escape character 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 vor dem Schließen eines doppelten Anführungszeichens endet, werden alle charAkteure, die bisher gelesen werden, 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. Das doppelte Anführungszeichen wird durch den umgekehrtenmain Umgekehrten Schrägstrich als Escapesequenz interpretiert, wodurch ein literales doppeltes Anführungszeichen (") platziert argvwird.

Beispiel für die Befehlszeilenargumentanalyse

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 Wildcardacterchar, das Fragezeichen (?) und Sternchen (*) verwenden, um Dateinamen- und Pfadargumente in der Befehlszeile anzugeben.

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

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