main Funktions- und Befehlszeilenargumente

  • Artikel

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 Klassenmember ohne explizite Initialisierer auf Null festgelegt. In Microsoft C++ werden globale static Objekte auch vor dem Eintrag in main. Es gelten mehrere Einschränkungen für die Funktion, die main nicht für andere C++-Funktionen gilt. Mit der Funktion main werden folgende Aktionen ausgeführt:

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

Die Signatur der main-Funktion

Die main-Funktion muss nicht deklariert werden, da sie in die Sprache integriert ist. Wäre eine Deklaration erforderlich, würde die Deklarationssyntax für main wie folgt aussehen:

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

Wenn kein Rückgabewert angegeben mainist, stellt der Compiler einen Rückgabewert von Null zur Verfügung.

Standard-Befehlszeilenargumente

Die Argumente für main eine bequeme Befehlszeilenanalyse von Argumenten. Die Typen für argc und argv werden von der Programmiersprache definiert. Die Namen argc sind argv traditionell, aber Sie können sie beliebig benennen.

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. Gemäß der Konvention ist argv[0] der Befehl, 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. Unter Windows ist es jedoch möglich, einen Prozess mithilfe CreateProcessvon . zu erstellen. Wenn Sie sowohl die ersten als auch die zweiten Argumente (lpApplicationName und lpCommandLine) verwenden, argv[0] ist dies möglicherweise nicht der name der ausführbaren Datei. Sie können GetModuleFileName den namen der ausführbaren Datei und den vollqualifizierten Pfad abrufen.

Microsoft-spezifische Erweiterungen

In den folgenden Abschnitten werden das microsoftspezifische Verhalten beschrieben.

Die Funktion und _tmain das wmain Makro

Wenn Sie Ihren Quellcode so entwerfen, dass unicodeweite charAkter verwendet werden, können Sie den microsoftspezifischen wmain Einstiegspunkt verwenden, der die breitchar handelnde Version 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, bei dem es sich um ein Präprozessormakro handelt, das in tchar.h. _tmain wird aufgelöst, main es sei denn _UNICODE , sie 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.

Rückgabe void von main

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. Sie steht für Symmetrie zur Verfügung, wenn main kein Wert zurückgegeben wird.

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

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 beliebig benennen. 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, 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 char (char *envp[]) oder als Zeiger auf char (char **envp) deklariert werden. Wenn Ihr Programm wmain anstelle des Datentyps mainverwendet wird, verwenden Sie den wchar_t Datentyp anstelle von char.

Der an die wmain Umgebung übergebene main Umgebungsblock ist eine "fixierte" Kopie der aktuellen Umgebung. Wenn Sie die Umgebung später ändern, indem Sie einen Aufruf oder putenv_wputenveinen Aufruf vornehmen, ändert sich die aktuelle Umgebung (wie zurückgegeben von getenv oder _wgetenv und die _environ Variable _wenviron ), aber der block, auf envp den verwiesen wird, ä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 Argumente und die argcargvenvp Folgenden mainverwenden:

// 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, die in der Befehlszeile des Betriebssystems 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 Teile, die von doppelten 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. Das Caret (^) wird nicht als Escape-Acter charoder 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 charbisher gelesenen Akteure 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 umgekehrtenmainSchrägstrich als Escapesequenz interpretiert, wodurch ein literales doppeltes Anführungszeichen (") eingefügt 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 wild Kartechar acters, das Fragezeichen (?) und das Sternchen (*) verwenden, um Dateinamen- und Pfadargumente in der Befehlszeile anzugeben.

Befehlszeilenargumente werden von einer internen Routine im Laufzeitstartcode behandelt, die standardmäßig nicht in wilden Zeichenfolgen erweitert wird Karte in separate Zeichenfolgen im argv Zeichenfolgenarray. Sie können die Erweiterung "wild Karte" 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.

Siehe auch

Basic concepts (Grundlegende Konzepte)