Namensräume
Varianten
Aktionen

Main-Funktion

Von cppreference.com
< cpp‎ | Sprache
 
 
C++ Sprache
Allgemeine Themen
Kontrollfluss
Bedingte Ausführungsaussagen
if
Iterationsanweisungen (Schleifen)
for
Bereichs-for (C++11)
Sprunganweisungen
Funktionen
Funktionsdeklaration
Lambda-Funktionsausdruck
inline-Spezifizierer
Dynamische Ausnahmespezifikationen (bis C++17*)
noexcept-Spezifizierer (C++11)
Ausnahmen
Namensräume
Typen
Spezifizierer
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Speicherdauer-Spezifizierer
Initialisierung
Ausdrücke
Alternative Darstellungen
Literale
Boolesch - Ganzzahl - Gleitkommazahl
Zeichen - String - nullptr (C++11)
Benutzerdefinierte (C++11)
Dienstprogramme
Attribute (C++11)
Typen
typedef-Deklaration
Typalias-Deklaration (C++11)
Umwandlungen
Speicherzuweisung
Klassen
Klassenspezifische Funktionseigenschaften
explicit (C++11)
static

Spezielle Member-Funktionen
Templates
Sonstiges
 
 

Ein Programm muss eine globale Funktion namens main enthalten, die der definierte Startpunkt des Programms in einer gehosteten Umgebung ist. Sie muss eine der folgenden Formen haben:

int main() { body } (1)
int main(int argc, char* argv[]) { body } (2)
int main(/* implementation-defined */) { body } (3)
1) Eine main-Funktion, die unabhängig von umgebungsgestellten Argumenten ausgeführt wird.
2) Eine main-Funktion, die umgebungsgestellte Argumente akzeptiert.
Die Namen von argc und argv sind beliebig, ebenso wie die Darstellung der Parametertypen: int main(int ac, char** av) ist ebenso gültig.
3) Eine main-Funktion von implementierungsdefiniertem Typ, die int zurückgibt.
Der C++-Standard empfiehlt für implementierungsdefinierte 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 darstellt, 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 vorhergehenden, falls vorhanden, auf null-terminierte Multibyte-Zeichenketten zeigen, die die vom Ausführungsumfeld an das Programm übergebenen Argumente darstellen. Wenn argv[0] kein Nullzeiger ist (oder äquivalent, wenn argc > 0), zeigt er auf eine Zeichenkette, die den Namen darstellt, mit dem das Programm aufgerufen wurde, oder auf eine leere Zeichenkette.
body - Der Körper der main-Funktion.

Inhalt

[bearbeiten] Erklärung

Die main-Funktion wird beim Programmstart aufgerufen, nachdem die nicht-lokalen Objekte mit statischer Speicherdauer initialisiert wurden. Sie ist der definierte Einstiegspunkt für ein Programm, das in einer gehosteten Umgebung (d. h. mit einem Betriebssystem) ausgeführt wird. Die Einstiegspunkte für freistehende Programme (Bootloader, Betriebssystem-Kernel usw.) sind implementierungsdefiniert.

Die Parameter der Zwei-Parameter-Form der main-Funktion ermöglichen die Übergabe beliebiger Multibyte-Zeichenketten aus der Ausführungsumgebung (diese werden typischerweise als Kommandozeilenargumente bezeichnet); 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 erste Zeichen einer null-terminierten Multibyte-Zeichenkette, die den Namen darstellt, 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ückpropagiert werden: Sie können beispielsweise mit std::strtok verwendet werden. Die Größe des von argv zeigenden Arrays beträgt mindestens argc + 1, und das letzte Element, argv[argc], ist garantiert ein Nullzeiger.

Die main-Funktion hat mehrere spezielle Eigenschaften:

1) Der Körper der main-Funktion muss keine return-Anweisung enthalten: Wenn die Kontrolle das Ende von main erreicht, ohne auf eine return-Anweisung zu stoßen, ist die Auswirkung, als ob return 0; ausgeführt würde.
2) Die Ausführung der Rückgabe (oder der impliziten Rückgabe beim Erreichen des Endes von main) entspricht dem normalen Verlassen der Funktion (was die Objekte mit automatischer Speicherdauer zerstörtund alle Nachbedingungsprüfungen von main auswertet(seit C++26)) und anschließendem Aufruf von std::exit mit demselben Argument wie dem Argument der return-Anweisung (std::exit zerstört dann statische Objekte und beendet das Programm).

Die main-Funktion hat mehrere Einschränkungen (deren Verletzung das Programm ill-formed macht):

1) Sie kann nirgends im Programm benannt werden.
a) Insbesondere kann sie nicht rekursiv aufgerufen werden.
b) Ihre Adresse kann nicht genommen werden.
c) Sie kann nicht in einem typeid-Ausdruck oder in einem decltype-Spezifizierer verwendet werdenoder einem decltype-Spezifizierer(seit C++11).
2) Sie kann nicht vordefiniert oder überladen werden: Der Name main im globalen Namespace ist effektiv für Funktionen reserviert (obwohl er zum Benennen von Klassen, Namespaces, Aufzählungen und Entitäten in einem nicht-globalen Namespace verwendet werden kann, mit der Ausnahme, dass ein als main benanntes Entität nicht mit C Sprachverknüpfung in einem beliebigen Namespace deklariert werden kann.
3) Sie darf nicht als gelöscht definiert werden oder(seit C++11) mit einer Sprachverknüpfung, constexpr(seit C++11), consteval(seit C++20), inline oder static deklariert werden.
4) Der Rückgabetyp der main-Funktion kann nicht abgeleitet werden (auto main() {...} ist nicht erlaubt).
(seit C++14)
5) Die main-Funktion darf keine Coroutine sein.
6) Die main-Funktion darf keinem benannten Modul zugeordnet werden.
(seit C++20)

[bearbeiten] Hinweise

Wenn die main-Funktion mit einem Funktions-try-Block definiert wird, werden die von den Destruktoren statischer Objekte (die durch den implizierten std::exit zerstört werden) geworfenen Ausnahmen von diesem nicht gefangen.

Die Art und Weise, wie die an der OS-Kommandozeile übergebenen Argumente in die Multibyte-Zeichen-Arrays konvertiert werden, auf die argv verweist, kann eine implementierungsdefinierte Verarbeitung beinhalten.

Eine sehr verbreitete implementierungsdefinierte 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 des Ausführungsumfelds zeigt.

[bearbeiten] Beispiel

Demonstriert, wie ein Programm darüber informiert wird, wo seine Eingaben zu finden und wo seine Ergebnisse zu schreiben sind.
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

[bearbeiten] Referenzen

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

[bearbeiten] Defect Reports

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

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

[bearbeiten] Siehe auch

C-Dokumentation für main-Funktion