Namespaces
Variants

Main function

From cppreference.net
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous

Ein Programm muss eine globale Namespace-Funktion namens main enthalten, die den festgelegten Startpunkt des Programms in einer gehosteten Umgebung darstellt. Sie muss eine der folgenden Formen haben:

int main() { Rumpf } (1)
int main( int argc , char * argv [] ) { Rumpf } (2)
int main( /* implementationsdefiniert */ ) { Rumpf } (3)
1) Eine main -Funktion, die unabhängig von umgebungsbereitgestellten Argumenten läuft.
2) Eine main -Funktion, die umgebungsbereitgestellte Argumente akzeptiert.
Die Namen von argc und argv sind beliebig, ebenso wie die Darstellung der Typen der Parameter: int main ( int ac, char ** av ) ist gleichermaßen gültig.
3) Eine main -Funktion mit implementierungsdefiniertem Typ, die int zurückgibt.
Der C++-Standard empfiehlt implementierungsdefinierten main -Funktionen, die zusätzlichen (optionalen) Parameter nach argv zu platzieren.
argc - Nicht-negativer Wert, der die Anzahl der an das Programm übergebenen Argumente aus der Umgebung repräsentiert, in der das Programm ausgeführt wird.
argv - Zeiger auf das erste Element eines Arrays von argc + 1 Zeigern, von denen der letzte ein Nullzeiger ist und die vorherigen, falls vorhanden, auf nullterminierte Multibyte-Zeichenketten zeigen, die die an das Programm übergebenen Argumente aus der Ausführungsumgebung repräsentieren. Wenn argv [ 0 ] kein Nullzeiger ist (oder äquivalent, wenn argc > 0 ), zeigt es auf eine Zeichenkette, die den Namen repräsentiert, mit dem das Programm aufgerufen wurde, oder auf eine leere Zeichenkette.
body - Der Rumpf der main -Funktion.

Inhaltsverzeichnis

Erklärung

Die main -Funktion wird beim Programmstart nach der Initialisierung der nicht-lokalen Objekte mit statischer Speicherdauer aufgerufen. Sie ist der festgelegte Einsprungspunkt für ein Programm, das in einer gehosteten Umgebung ausgeführt wird (d.h. mit einem Betriebssystem). Die Einsprungspunkte für freistehende Programme (Bootloader, Betriebssystemkerne etc.) sind implementierungsdefiniert.

Die Parameter der zweiparametrigen Form der main -Funktion ermöglichen die Übergabe beliebiger Multibyte-Zeichenketten aus der Ausführungsumgebung (üblicherweise als Kommandozeilenargumente bekannt). Die Zeiger [ argv [ 1 ] , argv [ argc - 1 ] ] zeigen auf die ersten Zeichen jeder dieser Zeichenketten. argv [ 0 ] (falls nicht null) ist der Zeiger auf das Anfangszeichen einer nullterminierten Multibyte-Zeichenkette, die den Namen repräsentiert, mit dem das Programm selbst aufgerufen wurde (oder eine leere Zeichenkette "" , falls dies von der Ausführungsumgebung nicht unterstützt wird). Die Zeichenketten sind modifizierbar, obwohl diese Änderungen nicht an die Ausführungsumgebung zurückgegeben werden: Sie können beispielsweise mit std::strtok verwendet werden. Die Größe des von argv referenzierten Arrays beträgt mindestens argc + 1 , und das letzte Element, argv [ argc ] , ist garantiert ein Nullzeiger.

Die main Funktion besitzt die folgenden besonderen Eigenschaften:

1) Der Rumpf der main -Funktion muss keine return -Anweisung enthalten: Wenn der Kontrollfluss das Ende von main erreicht, ohne auf eine return-Anweisung zu stoßen, ist der Effekt gleichbedeutend mit der Ausführung von return 0 ; .
2) Die Ausführung des return (oder des impliziten return beim Erreichen des Endes von main ) entspricht dem zuerst normalen Verlassen der Funktion (was die Objekte mit automatischer Speicherdauer zerstört und alle Postcondition Assertions von main auswertet (since C++26) ) und dann dem Aufruf von std::exit mit demselben Argument wie das Argument des return ( std::exit zerstört dann statische Objekte und beendet das Programm).

Die main -Funktion unterliegt mehreren Einschränkungen (deren Verletzung das Programm fehlerhaft macht):

1) Es kann nirgendwo im Programm benannt werden
a) insbesondere kann es nicht rekursiv aufgerufen werden
b) seine Adresse kann nicht ermittelt werden
c) es kann nicht in einem typeid -Ausdruck verwendet werden oder einem decltype -Spezifizierer (seit C++11)
2) Es kann nicht vordefiniert und nicht überladen werden: effektiv ist der Name main im globalen Namensraum für Funktionen reserviert (obwohl er zur Benennung von Klassen, Namensräumen, Aufzählungen und beliebigen Entitäten in einem nicht-globalen Namensraum verwendet werden kann, mit der Ausnahme, dass eine Entität namens main nicht mit C Sprachbindung in einem beliebigen Namensraum deklariert werden kann).
3) Es kann nicht als gelöscht definiert oder (since C++11) mit beliebiger Sprachbindung deklariert werden , constexpr (since C++11) , consteval (since C++20) , inline , oder static .
4) Der Rückgabetyp der main -Funktion kann nicht abgeleitet werden ( auto main ( ) { ... } ist nicht erlaubt).
(seit C++14)
5) Die main -Funktion kann keine Coroutine sein.
6) Die main -Funktion kann keinem benannten Modul zugeordnet werden.
(seit C++20)

Hinweise

Wenn die main -Funktion mit einem Funktions- try -Block definiert wird, werden die Ausnahmen, die von den Destruktoren statischer Objekte ausgelöst werden (die durch den impliziten Aufruf von std::exit zerstört werden), nicht davon abgefangen .

Die Art und Weise, in der die Argumente, die in der OS-Kommandozeile angegeben werden, in die Multibyte-Zeichenarrays konvertiert werden, auf die durch argv verwiesen wird, kann implementierungsdefinierte Verarbeitung beinhalten:

Eine sehr häufige implementationsdefinierte Form von main ( ) hat ein drittes Argument (zusätzlich zu argc und argv ) vom Typ char ** , das auf ein Array von Zeigern auf die Umgebungsvariablen zeigt.

Beispiel

Demonstriert, wie ein Programm darüber informiert wird, wo es seine Eingaben findet und wo es seine Ergebnisse schreiben soll.
Ein möglicher Aufruf: . / convert table_in. dat table_out. dat

#include <cstdlib>
#include <iomanip>
#include <iostream>
int main(int argc, char *argv[])
{
    std::cout << "argc == " << argc << '\n';
    for (int ndx{}; ndx != argc; ++ndx)
        std::cout << "argv[" << ndx << "] == " << std::quoted(argv[ndx]) << '\n';
    std::cout << "argv[" << argc << "] == "
              << static_cast<void*>(argv[argc]) << '\n';
    /* ... */
    return argc == 3 ? EXIT_SUCCESS : EXIT_FAILURE; // optional return value
}

Mögliche Ausgabe:

argc == 3
argv[0] == "./convert"
argv[1] == "table_in.dat"
argv[2] == "table_out.dat"
argv[3] == 0

Referenzen

Erweiterter Inhalt
  • C++23-Standard (ISO/IEC 14882:2024):
  • 6.9.3.1 main-Funktion [basic.start.main]

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
CWG 1003 C++98 unterstützte Parameternamen von main waren zu stark eingeschränkt alle gültigen Parameter-
namen werden unterstützt
CWG 1886 C++98 die main -Funktion konnte mit einer Sprachbindung deklariert werden verboten
CWG 2479 C++20 die main -Funktion konnte als consteval deklariert werden verboten
CWG 2811 C++98 es war unklar, ob die main -Funktion nach N3214 verwendet wird sie wird als verwendet betrachtet, wenn benannt

Siehe auch

C-Dokumentation für main Funktion