C++
Kompilieren und Bauen

Einführung

Bemerkungen

Kompilieren mit GCC

Unter der Annahme einer einzigen Quelldatei namens main.cpp den Befehl, zu kompilieren und verknüpfen eine nicht optimierte ausführbare Datei ist wie folgt (ohne Optimierung Kompilieren ist nützlich für die anfängliche Entwicklung und Debugging, obwohl -Og offiziell für neuere GCC - Versionen wird empfohlen).

g++ -o app -Wall main.cpp -O0

Um eine optimierte ausführbare Datei für die Verwendung in der Produktion zu erstellen, verwenden Sie eine der Optionen -O (siehe: -O1 , -O2 , -O3 , -Os , -Ofast ):

g++ -o app -Wall -O2 main.cpp

Wenn die Option -O weggelassen wird, wird standardmäßig -O0 (dh keine Optimierungen) verwendet (Angabe von -O ohne Zahl wird in -O1 aufgelöst).

Alternativ können Sie Optimierungsflags aus den O Gruppen (oder mehr experimentelle Optimierungen) direkt verwenden. Das folgende Beispiel erstellt mit -O2 Optimierung plus ein Flag aus der -O3 Optimierungsebene:

g++ -o app -Wall -O2 -ftree-partial-pre main.cpp

Um eine plattformspezifische optimierte ausführbare Datei (zur Verwendung in der Produktion auf der Maschine mit der gleichen Architektur) zu erstellen, verwenden Sie Folgendes:

g++ -o app -Wall -O2 -march=native main.cpp

In .\app.exe ./app wird eine Binärdatei erstellt, die mit .\app.exe unter Windows und ./app unter Linux, Mac OS usw. ausgeführt werden kann.

Das Flag -o kann auch übersprungen werden. In diesem Fall erstellt GCC die Standard-Ausgabedatei a.exe unter Windows und a.out auf Unix-ähnlichen Systemen. Um eine Datei ohne Verknüpfung zu kompilieren, verwenden Sie die Option -c :

g++ -o file.o -Wall -c file.cpp

Dies erzeugt eine Objektdatei namens file.o die später mit anderen Dateien verknüpft werden kann, um eine Binärdatei zu erzeugen:

g++ -o app file.o otherfile.o

Weitere Informationen zu Optimierungsoptionen finden Sie unter gcc.gnu.org . Besonders hervorzuheben sind -Og (Optimierung mit Schwerpunkt Debugging-Erfahrung - empfohlen für den standardmäßigen Edit-Compile-Debug-Zyklus) und -Ofast (alle Optimierungen, auch wenn die strikte Einhaltung der Standards nicht beachtet wird).

Das -Wall Flag -Wall Warnungen für viele häufige Fehler und sollte immer verwendet werden. Um die Codequalität zu verbessern, wird häufig auch -Wextra , -Wextra und andere Warnflags zu verwenden, die nicht automatisch von -Wall und -Wextra .

Wenn der Code einen bestimmten C ++ - Standard erwartet, geben Sie an, welcher Standard verwendet werden soll, indem Sie das -std= angeben. Unterstützte Werte entsprechen dem Jahr der Fertigstellung für jede Version des ISO C ++ - Standards. Gültige Werte für das Flag std= sind seit GCC 6.1.0 c++98 / c++03 , c++11 , c++14 und c++17 / c++1z . Werte, die durch einen Schrägstrich getrennt sind, sind gleichwertig.

g++ -std=c++11 <file>

GCC enthält einige compilerspezifische Erweiterungen, die deaktiviert werden, wenn sie mit einem durch das -std= angegebenen Standard in Konflikt stehen. Zum Kompilieren mit allen aktivierten Erweiterungen kann der Wert gnu++XX verwendet werden, wobei XX eines der Jahre ist, die von den oben aufgeführten c++ Werten verwendet werden.

Der Standardstandard wird verwendet, wenn keiner angegeben wird. Für GCC-Versionen vor 6.1.0 lautet der Standardwert -std=gnu++03 ; In GCC 6.1.0 und höher lautet der Standardwert -std=gnu++14 .

Beachten Sie, dass aufgrund von Fehlern in GCC das Flag -pthread beim Kompilieren und Verknüpfen vorhanden sein muss, damit GCC die mit C ++ 11 eingeführte C ++ - Standard-Threading-Funktionalität unterstützt, z. B. std::thread und std::wait_for . Das Auslassen bei Verwendung von Threading-Funktionen kann auf einigen Plattformen zu keinen Warnungen, aber zu ungültigen Ergebnissen führen .

Verlinkung mit Bibliotheken:

Verwenden Sie die Option -l , um den Bibliotheksnamen zu übergeben:

g++ main.cpp -lpcre2-8
#pcre2-8 is the PCRE2 library for 8bit code units (UTF-8)

Wenn sich die Bibliothek nicht im Standardbibliothekpfad befindet, fügen Sie den Pfad mit der Option -L :

g++ main.cpp -L/my/custom/path/ -lmylib

Mehrere Bibliotheken können miteinander verbunden werden:

g++ main.cpp -lmylib1 -lmylib2 -lmylib3

Wenn eine Bibliothek von einer anderen abhängig ist, platzieren Sie die abhängige Bibliothek vor der unabhängigen Bibliothek:

g++ main.cpp -lchild-lib -lbase-lib

Oder lassen Sie den Linker die Bestellung selbst über --start-group und --end-group (Hinweis: Dies hat erhebliche Leistungskosten zur Folge):

g++ main.cpp -Wl,--start-group -lbase-lib -lchild-lib -Wl,--end-group

Kompilieren mit Visual C ++ (Befehlszeile)

Für Programmierer, die von GCC oder Clang zu Visual Studio kommen, oder Programmierer, die im Allgemeinen mit der Befehlszeile vertraut sind, können Sie den Visual C ++ - Compiler über die Befehlszeile sowie die IDE verwenden.

Wenn Sie Ihren Code über die Befehlszeile in Visual Studio kompilieren möchten, müssen Sie zunächst die Befehlszeilenumgebung einrichten. Dies kann entweder durch Öffnen der Visual Studio Command Prompt von Visual Studio Command Prompt / Developer Command Prompt / x86 Native Tools Command Prompt / x64 Native Tools Command Prompt oder ähnliches (wie in Ihrer Version von Visual Studio bereitgestellt) oder über die Eingabeaufforderung durch Navigieren zu erfolgen das VC Unterverzeichnis des Installationsverzeichnisses des Compilers (normalerweise \Program Files (x86)\Microsoft Visual Studio x\VC , wobei x die Versionsnummer ist (z. B. 10.0 für 2010 oder 14.0 für 2015) und Ausführen der VCVARSALL Batchdatei mit einem Befehlszeilenparameter, der hier angegeben wird.

Beachten Sie, dass Visual Studio im Gegensatz zu GCC kein Front-End für den Linker ( link.exe ) über den Compiler ( cl.exe ) cl.exe , sondern den Linker als separates Programm bereitstellt, das der Compiler beim cl.exe aufruft. cl.exe und link.exe können separat mit verschiedenen Dateien und Optionen verwendet werden, oder cl kann angewiesen werden, Dateien und Optionen zum link wenn beide Aufgaben zusammen ausgeführt werden. Alle für cl angegebenen Verknüpfungsoptionen werden in link , und Dateien, die nicht von cl verarbeitet werden, werden direkt an den link . Da dies hauptsächlich eine einfache Anleitung zum Kompilieren mit der Visual Studio-Befehlszeile ist, werden die Argumente für die link derzeit nicht beschrieben. Wenn Sie eine Liste benötigen, sehen Sie hier .

Beachten Sie, dass Argumente für cl die Groß- und Kleinschreibung berücksichtigen, Argumente für die link nicht.

[Bitte beachten Sie, dass einige der folgenden Beispiele die Windows-Shell-Variable "Aktuelles Verzeichnis" %cd% , wenn Sie absolute Pfadnamen angeben. Für alle, die mit dieser Variablen nicht vertraut sind, wird sie zum aktuellen Arbeitsverzeichnis erweitert. In der Befehlszeile ist dies das Verzeichnis, in dem Sie sich zum Zeitpunkt der Ausführung von " cl befanden, und das standardmäßig in der Eingabeaufforderung angegeben wird (wenn Ihre Eingabeaufforderung beispielsweise C:\src> lautet, ist %cd% C:\src\ ).]

Angenommen, eine einzige Quelldatei mit dem Namen " main.cpp im aktuellen Ordner lautet der Befehl zum Kompilieren und Verknüpfen einer nicht optimierten ausführbaren Datei (nützlich für die anfängliche Entwicklung und das Debuggen) (verwenden Sie eine der folgenden Möglichkeiten):

cl main.cpp
// Generates object file "main.obj".
// Performs linking with "main.obj".
// Generates executable "main.exe".

cl /Od main.cpp
// Same as above.
// "/Od" is the "Optimisation: disabled" option, and is the default when no /O is specified.

Wenn Sie eine zusätzliche Quelldatei "niam.cpp" in demselben Verzeichnis annehmen, verwenden Sie Folgendes:

cl main.cpp niam.cpp
// Generates object files "main.obj" and "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

Sie können auch Platzhalterzeichen verwenden, wie zu erwarten wäre:

cl main.cpp src\*.cpp
// Generates object file "main.obj", plus one object file for each ".cpp" file in folder
//  "%cd%\src".
// Performs linking with "main.obj", and every additional object file generated.
// All object files will be in the current folder.
// Generates executable "main.exe".

Um die ausführbare Datei umzubenennen oder zu verschieben, verwenden Sie eine der folgenden Möglichkeiten:

cl /o name main.cpp
// Generates executable named "name.exe".

cl /o folder\ main.cpp
// Generates executable named "main.exe", in folder "%cd%\folder".

cl /o folder\name main.cpp
// Generates executable named "name.exe", in folder "%cd%\folder".

cl /Fename main.cpp
// Same as "/o name".

cl /Fefolder\ main.cpp
// Same as "/o folder\".

cl /Fefolder\name main.cpp
// Same as "/o folder\name".

Beide /o und /Fe übergeben ihre Parameter (nennen wir sie o-param ), link als /OUT:o-param zu link und /OUT:o-param die entsprechende Erweiterung (im Allgemeinen .exe oder .dll ) an " o-param wenn dies erforderlich ist. Während /o und /Fe meines Wissens in der Funktionalität identisch sind, wird letzteres für Visual Studio bevorzugt. /o ist als veraltet markiert und scheint hauptsächlich für Programmierer vorgesehen zu sein, die mit GCC oder Clang vertraut sind.

Beachten Sie, dass das Leerzeichen zwischen /o und dem angegebenen Ordner und / oder Namen optional ist, es darf jedoch kein Leerzeichen zwischen /Fe und dem angegebenen Ordner und / oder Namen geben.

Um eine optimierte ausführbare Datei (für die Verwendung in der Produktion) zu erstellen, verwenden Sie Folgendes:

cl /O1 main.cpp
// Optimise for executable size.  Produces small programs, at the possible expense of slower
//  execution.

cl /O2 main.cpp
// Optimise for execution speed.  Produces fast programs, at the possible expense of larger
//  file size.

cl /GL main.cpp other.cpp
// Generates special object files used for whole-program optimisation, which allows CL to
//  take every module (translation unit) into consideration during optimisation.
// Passes the option "/LTCG" (Link-Time Code Generation) to LINK, telling it to call CL during
//  the linking phase to perform additional optimisations.  If linking is not performed at this
//  time, the generated object files should be linked with "/LTCG".
// Can be used with other CL optimisation options.

Um schließlich eine plattformspezifische, optimierte ausführbare Datei zu erstellen (zur Verwendung auf der Maschine mit der angegebenen Architektur in der Produktion), wählen Sie die entsprechende Eingabeaufforderung oder den VCVARSALL Parameter für die Zielplattform aus. link sollte die gewünschte Plattform aus den Objektdateien erkennen; Wenn nicht, verwenden Sie die Option /MACHINE , um die Zielplattform explizit anzugeben.

// If compiling for x64, and LINK doesn't automatically detect target platform:
cl main.cpp /link /machine:X64

Eine der oben genannten Dateien erzeugt eine ausführbare Datei mit dem durch /o oder /Fe angegebenen Namen oder, falls keine angegeben ist, mit einem Namen, der mit der ersten Quell- oder Objektdatei identisch ist, die im Compiler angegeben wurde.

cl a.cpp b.cpp c.cpp
// Generates "a.exe".

cl d.obj a.cpp q.cpp
// Generates "d.exe".

cl y.lib n.cpp o.obj
// Generates "n.exe".

cl /o yo zp.obj pz.cpp
// Generates "yo.exe".

Um eine Datei (en) ohne Verknüpfung zu kompilieren, verwenden Sie:

cl /c main.cpp
// Generates object file "main.obj".

Dies weist cl an, das Programm ohne Aufruf einer link zu beenden, und erzeugt eine Objektdatei, die später mit anderen Dateien verknüpft werden kann, um eine Binärdatei zu erstellen.

cl main.obj niam.cpp
// Generates object file "niam.obj".
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

link main.obj niam.obj
// Performs linking with "main.obj" and "niam.obj".
// Generates executable "main.exe".

Es gibt auch andere wertvolle Befehlszeilenparameter, die für Benutzer sehr nützlich sein könnten:

cl /EHsc main.cpp
// "/EHsc" specifies that only standard C++ ("synchronous") exceptions will be caught,
//  and `extern "C"` functions will not throw exceptions.
// This is recommended when writing portable, platform-independent code.

cl /clr main.cpp
// "/clr" specifies that the code should be compiled to use the common language runtime,
//  the .NET Framework's virtual machine.
// Enables the use of Microsoft's C++/CLI language in addition to standard ("native") C++,
//  and creates an executable that requires .NET to run.

cl /Za main.cpp
// "/Za" specifies that Microsoft extensions should be disabled, and code should be
//  compiled strictly according to ISO C++ specifications.
// This is recommended for guaranteeing portability.

cl /Zi main.cpp
// "/Zi" generates a program database (PDB) file for use when debugging a program, without
//  affecting optimisation specifications, and passes the option "/DEBUG" to LINK.

cl /LD dll.cpp
// "/LD" tells CL to configure LINK to generate a DLL instead of an executable.
// LINK will output a DLL, in addition to an LIB and EXP file for use when linking.
// To use the DLL in other programs, pass its associated LIB to CL or LINK when compiling those
//  programs.

cl main.cpp /link /LINKER_OPTION
// "/link" passes everything following it directly to LINK, without parsing it in any way.
// Replace "/LINKER_OPTION" with any desired LINK option(s).

Für alle, die mit * nix-Systemen und / oder GCC / Clang-Systemen vertraut sind, können cl , link und andere Visual Studio-Befehlszeilen-Tools anstelle eines Schrägstrichs (wie /c ) mit einem Bindestrich (wie -c ) angegebene Parameter akzeptieren. Darüber hinaus erkennt Windows entweder einen Schrägstrich oder einen umgekehrten Schrägstrich als gültiges Pfadtrennzeichen. Daher können auch * nix-Pfade verwendet werden. Dies macht es einfach, einfache Compiler-Befehlszeilen von g++ oder clang++ in cl oder umgekehrt mit minimalen Änderungen zu konvertieren.

g++ -o app src/main.cpp
cl  -o app src/main.cpp

Wenn Sie Befehlszeilen portieren, die komplexere g++ oder clang++ Optionen verwenden, müssen Sie natürlich entsprechende Befehle in den entsprechenden Compilerdokumentationen und / oder auf Ressourcensites nachschlagen. Dies erleichtert jedoch den Einstieg mit minimalem Zeitaufwand neue Compiler.

Falls Sie für Ihren Code bestimmte Sprachfunktionen benötigen, war eine spezielle Version von MSVC erforderlich. Ab Visual C ++ 2015 Update 3 ist es möglich, die Version des Standards, mit der kompiliert werden soll, über das Flag /std auszuwählen. Mögliche Werte sind /std:c++14 und /std:c++latest ( /std:c++17 wird in Kürze folgen).

Hinweis: In älteren Versionen dieses Compilers waren bestimmte Feature-Flags verfügbar. Diese wurden jedoch hauptsächlich für die Vorschau neuer Features verwendet.

Kompilieren mit Visual Studio (grafische Benutzeroberfläche) - Hello World

1. Laden Sie Visual Studio Community 2015 herunter und installieren Sie es
2. Öffnen Sie die Visual Studio Community
3. Klicken Sie auf Datei -> Neu -> Projekt
4. Klicken Sie auf Vorlagen -> Visual C ++ -> Win32-Konsolenanwendung, und nennen Sie das Projekt MyFirstProgram .
5. OK klicken
6. Klicken Sie im folgenden Fenster auf Weiter.
7. Aktivieren Sie das Kontrollkästchen " Empty project " und klicken Sie auf "Fertig stellen".
8. Klicken Sie mit der rechten Maustaste auf den Ordner Quelldatei und dann auf -> Hinzufügen -> Neues Element:
9. Wählen Sie die C ++ - Datei aus und benennen Sie die Datei main.cpp. Klicken Sie dann auf Hinzufügen: 10: Kopieren Sie den folgenden Code und fügen Sie ihn in die neue Datei main.cpp ein:

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
    return 0;
}

Ihre Umgebung sollte folgendermaßen aussehen:

11. Klicken Sie auf Debuggen -> Starten ohne Debuggen (oder drücken Sie Strg + F5):

12. Erledigt. Sie sollten die folgende Konsolenausgabe erhalten:

Kompilieren mit Clang

Da das Clang- Frontend für die Kompatibilität mit GCC ausgelegt ist, werden die meisten Programme, die über GCC kompiliert werden können, kompiliert, wenn Sie g++ durch clang++ in den Build-Skripts austauschen. Wenn keine -std=version angegeben ist, wird gnu11 verwendet.

Windows-Benutzer, die an MSVC cl.exe sind, können cl.exe mit clang-cl.exe . Standardmäßig versucht clang, mit der höchsten installierten Version von MSVC kompatibel zu sein.

Beim Kompilieren mit Visual Studio kann clang-cl verwendet werden, indem das Platform toolset in den Projekteigenschaften geändert wird.

In beiden Fällen ist clang nur über sein Frontend kompatibel, versucht jedoch auch, binärkompatible Objektdateien zu generieren. Benutzer von clang-cl sollten beachten, dass die Kompatibilität mit MSVC noch nicht vollständig ist .

Um clang oder clang-cl zu verwenden, könnte man die Standardinstallation auf bestimmten Linux-Distributionen oder mit IDEs gebündelten verwenden (wie XCode auf Mac). Für andere Versionen dieses Compilers oder auf Plattformen, auf denen dies nicht installiert ist, können Sie diese von der offiziellen Download-Seite herunterladen .

Wenn Sie CMake verwenden, um Ihren Code zu erstellen, können Sie normalerweise den Compiler wechseln, indem Sie die CC und CXX Umgebungsvariablen wie CXX :

mkdir build
cd build
CC=clang CXX=clang++ cmake ..
cmake --build .

Siehe auch Einführung in Cmake .

Online-Compiler

Verschiedene Websites bieten Online-Zugriff auf C ++ - Compiler. Der Funktionsumfang des Online-Compilers variiert erheblich von Website zu Site. In der Regel können Sie jedoch Folgendes tun:

• Fügen Sie Ihren Code in ein Webformular im Browser ein.
• Wählen Sie einige Compileroptionen aus und kompilieren Sie den Code.
• Sammeln Sie Compiler- und / oder Programmausgaben.

Das Verhalten der Website von Online-Compilern ist in der Regel recht restriktiv, da jeder Compiler ausführen und beliebigen Code auf der Serverseite ausführen kann, während die Ausführung von beliebigem Remote-Code normalerweise als Schwachstelle angesehen wird.

Online-Compiler können für folgende Zwecke nützlich sein:

• Führen Sie ein kleines Code-Snippet von einem Computer aus, auf dem der C ++ - Compiler fehlt (Smartphones, Tablets usw.).
• Stellen Sie sicher, dass Code erfolgreich mit verschiedenen Compilern kompiliert wird und auf dieselbe Weise ausgeführt wird, unabhängig davon, mit welchem ​​Compiler er kompiliert wurde.
• Lernen oder lehren Sie Grundlagen von C ++.
• Lernen Sie moderne C ++ - Funktionen (in naher Zukunft C ++ 14 und C ++ 17) kennen, wenn auf dem lokalen Computer kein aktueller C ++ - Compiler verfügbar ist.
• Finden Sie einen Fehler in Ihrem Compiler im Vergleich zu einer großen Anzahl anderer Compiler. Prüfen Sie, ob in zukünftigen Versionen ein Compiler-Fehler behoben wurde, der auf Ihrem Computer nicht verfügbar ist.
• Lösen Sie Online-Richterprobleme.

Wofür Online-Compiler nicht verwendet werden sollten:

• Entwickeln Sie voll funktionsfähige (auch kleine) Anwendungen mit C ++. Normalerweise erlauben Online-Compiler keine Verknüpfung mit Bibliotheken von Drittanbietern oder das Herunterladen von Build-Artefakten.
• Führen Sie intensive Berechnungen durch. Die Rechenressourcen für andere Rechner sind begrenzt, so dass jedes vom Benutzer bereitgestellte Programm nach einigen Sekunden der Ausführung abgebrochen wird. Die erlaubte Ausführungszeit reicht normalerweise zum Testen und Lernen aus.
• Angriff des Compilerservers selbst oder anderer Hosts im Internet.

Beispiele:

Haftungsausschluss: Dokumentationsautor (en) sind nicht mit den unten aufgeführten Ressourcen verbunden. Websites sind alphabetisch aufgelistet.

• http://codepad.org/ Online-Compiler mit Code-Sharing. Das Bearbeiten von Code nach dem Kompilieren mit einer Warnung oder einem Fehler im Quellcode funktioniert nicht so gut.
• http://coliru.stacked-crooked.com/ Online-Compiler, für den Sie die Befehlszeile angeben. Stellt sowohl GCC- als auch Clang-Compiler zur Verfügung.
• http://cpp.sh/ - Online-Compiler mit C ++ 14-Unterstützung. Sie können die Compiler-Befehlszeile nicht bearbeiten. Einige Optionen sind jedoch über GUI-Steuerelemente verfügbar.
• https://gcc.godbolt.org/ - Stellt eine umfangreiche Liste von Compilerversionen, Architekturen und Disassembly-Ausgaben bereit. Sehr nützlich, wenn Sie prüfen müssen, in was Ihr Code von verschiedenen Compilern übersetzt wird. GCC, Clang, MSVC ( CL ), Intel-Compiler ( icc ), ELLCC und Zapcc sind vorhanden, wobei einer oder mehrere dieser Compiler für ARM, ARMv8 (als ARM64), Atmel AVR, MIPS, MIPS64, MSP430 und PowerPC verfügbar sind , x86- und x64-Architekturen. Compiler-Befehlszeilenargumente können bearbeitet werden.
• https://ideone.com/ - Wird im Internet häufig verwendet, um das Verhalten von Codeausschnitten darzustellen. Bietet sowohl GCC als auch Clang zur Verwendung, erlaubt jedoch nicht die Bearbeitung der Compiler-Befehlszeile.
• http://melpon.org/wandbox - Unterstützt zahlreiche Clang- und GNU / GCC-Compilerversionen.
• http://onlinegdb.com/ - Eine extrem minimalistische IDE mit einem Editor, einem Compiler (gcc) und einem Debugger (gdb).
• http://rextester.com/ - Stellt Clang-, GCC- und Visual Studio-Compiler für C und C ++ (zusammen mit Compilern für andere Sprachen) bereit, wobei die Boost-Bibliothek zur Verfügung steht.
• http://tutorialspoint.com/compile_cpp11_online.php - Eine voll funktionsfähige UNIX-Shell mit GCC und ein benutzerfreundlicher Projektexplorer.
• http://webcompiler.cloudapp.net/ - Online Visual Studio 2015-Compiler, bereitgestellt von Microsoft als Teil von RiSE4fun.

Der C ++ - Kompilierungsprozess

Wenn Sie ein C ++ - Programm entwickeln, ist der nächste Schritt das Programm zu kompilieren, bevor Sie es ausführen. Die Kompilierung ist der Prozess, der das Programm in einer von Menschen lesbaren Sprache wie C, C ++ usw. in einen Maschinencode umwandelt, der direkt von der Central Processing Unit verstanden wird. Wenn Sie beispielsweise eine C ++ - Quellcodedatei mit dem Namen prog.cpp haben und den Kompilierungsbefehl ausführen,

   g++ -Wall -ansi -o prog prog.cpp

Es gibt vier Hauptschritte, um eine ausführbare Datei aus der Quelldatei zu erstellen.

1. Der C ++ - Präprozessor nimmt eine C ++ - Quellcodedatei und behandelt die Header (#include), Makros (#define) und andere Präprozessoranweisungen.

2. Die erweiterte C ++ - Quellcodedatei, die vom C ++ - Präprozessor erstellt wurde, wird in die Assembler-Sprache für die Plattform kompiliert.

3. Der vom Compiler generierte Assembler-Code wird im Objektcode für die Plattform zusammengefasst.

4. Die vom Assembler erzeugte Objektcodedatei ist miteinander verknüpft
   mit den Objektcodedateien für alle Bibliotheksfunktionen, die zum Erstellen einer Bibliothek oder einer ausführbaren Datei verwendet werden.

Vorverarbeitung

Der Präprozessor behandelt die Präprozessoranweisungen wie #include und #define. Es ist eine Agnostik der Syntax von C ++, weshalb es mit Vorsicht zu verwenden ist.

Es funktioniert für jeweils eine C ++ - Quelldatei, indem #include-Direktiven durch den Inhalt der jeweiligen Dateien ersetzt werden (was normalerweise nur Deklarationen ist), Makros ersetzt (#define) und verschiedene Textabschnitte in Abhängigkeit von #if ausgewählt werden. Anweisungen #ifdef und #ifndef.

Der Präprozessor arbeitet mit einem Strom von Vorverarbeitungstoken. Makrosubstitution ist definiert als Ersetzung von Token durch andere Token (der Operator ## ermöglicht das Zusammenführen von zwei Token, wenn dies sinnvoll ist).

Nach all dem erzeugt der Präprozessor eine einzige Ausgabe, die ein Tokenstrom ist, der aus den oben beschriebenen Transformationen resultiert. Außerdem werden einige spezielle Marker hinzugefügt, die dem Compiler mitteilen, woher die einzelnen Zeilen stammen, sodass er diese verwenden kann, um sinnvolle Fehlermeldungen zu erzeugen.

Einige Fehler können zu diesem Zeitpunkt unter Verwendung der Anweisungen #if und #error erzeugt werden.

Indem Sie das Compiler-Flag verwenden, können Sie den Prozess in der Vorverarbeitungsphase stoppen.

g++ -E prog.cpp

Zusammenstellung

Der Übersetzungsschritt wird an jedem Ausgang des Präprozessors durchgeführt. Der Compiler analysiert den reinen C ++ - Quellcode (jetzt ohne Präprozessoranweisungen) und konvertiert ihn in Assemblycode. Ruft dann das zugrunde liegende Back-End (Assembler in Toolchain) auf, der diesen Code zu Maschinencode zusammensetzt, um eine tatsächliche Binärdatei in einem bestimmten Format (ELF, COFF, a.out, ...) zu erstellen. Diese Objektdatei enthält den kompilierten Code (in binärer Form) der in der Eingabe definierten Symbole. Symbole in Objektdateien werden mit Namen bezeichnet.

Objektdateien können sich auf Symbole beziehen, die nicht definiert sind. Dies ist der Fall, wenn Sie eine Deklaration verwenden und keine Definition dafür angeben. Der Compiler hat nichts dagegen und wird die Objektdatei glücklich erzeugen, solange der Quellcode wohlgeformt ist.

Compiler lassen Sie normalerweise an diesem Punkt die Kompilierung abbrechen. Dies ist sehr nützlich, da Sie damit jede Quellcodedatei separat kompilieren können. Der Vorteil ist, dass Sie nicht alles neu kompilieren müssen, wenn Sie nur eine einzelne Datei ändern.

Die erzeugten Objektdateien können in speziellen Archiven, statischen Bibliotheken, abgelegt werden, um sie später wieder verwenden zu können.

In diesem Stadium werden "reguläre" Compiler-Fehler wie Syntaxfehler oder Fehler bei der Auflösung der Überladung gemeldet.

Um den Prozess nach dem Kompilierungsschritt zu stoppen, können Sie die Option -S verwenden:

g++ -Wall -ansi -S prog.cpp

Zusammenbau

Der Assembler erstellt Objektcode. Auf einem UNIX-System werden möglicherweise Dateien mit dem Suffix .o (.OBJ auf MSDOS) angezeigt, um Objektcodedateien anzuzeigen. In dieser Phase konvertiert der Assembler diese Objektdateien vom Assemblycode in Anweisungen auf Maschinenebene. Die erstellte Datei ist ein verschiebbarer Objektcode. In der Kompilierungsphase wird daher das verschiebbare Objektprogramm generiert, und dieses Programm kann an verschiedenen Stellen verwendet werden, ohne dass es erneut kompiliert werden muss.

Um den Prozess nach dem Montageschritt zu stoppen, können Sie die Option -c verwenden:

g++ -Wall -ansi -c prog.cpp

Verlinkung

Der Linker erzeugt die endgültige Kompilierungsausgabe aus den vom Assembler erzeugten Objektdateien. Diese Ausgabe kann entweder eine gemeinsam genutzte (oder dynamische) Bibliothek sein (und obwohl der Name ähnlich ist, haben sie mit den zuvor erwähnten statischen Bibliotheken nicht viel gemeinsam) oder einer ausführbaren Datei.

Es verknüpft alle Objektdateien, indem die Verweise auf undefinierte Symbole durch die richtigen Adressen ersetzt werden. Jedes dieser Symbole kann in anderen Objektdateien oder in Bibliotheken definiert werden. Wenn sie in anderen Bibliotheken als der Standardbibliothek definiert sind, müssen Sie den Linker darüber informieren.

Zu diesem Zeitpunkt sind die häufigsten Fehler fehlende Definitionen oder doppelte Definitionen. Ersteres bedeutet, dass entweder die Definitionen nicht existieren (dh sie werden nicht geschrieben) oder dass die Objektdateien oder Bibliotheken, in denen sie sich befinden, nicht an den Linker übergeben wurden. Letzteres ist offensichtlich: Das gleiche Symbol wurde in zwei verschiedenen Objektdateien oder Bibliotheken definiert.

Kompilieren mit Code :: Blocks (grafische Oberfläche)

1. Laden Sie Code :: Blocks hier herunter und installieren Sie sie. Wenn Sie unter Windows sind, wählen Sie eine Datei aus, für die der Name mingw enthält. Die anderen Dateien installieren keinen Compiler.

2. Öffnen Sie Code :: Blocks und klicken Sie auf "Neues Projekt erstellen":

   

3. Wählen Sie "Konsolenanwendung" und klicken Sie auf "Los":

   

4. Klicken Sie auf "Weiter", wählen Sie "C ++" aus, klicken Sie auf "Weiter", wählen Sie einen Namen für Ihr Projekt und wählen Sie einen Ordner zum Speichern aus, klicken Sie auf "Weiter" und klicken Sie dann auf "Fertig stellen".

5. Jetzt können Sie Ihren Code bearbeiten und kompilieren. Ein Standardcode, der "Hallo Welt!" in der Konsole ist schon da. Um Ihr Programm zu kompilieren und / oder auszuführen, drücken Sie eine der drei Schaltflächen zum Kompilieren / Ausführen in der Symbolleiste:

   

   Um zu kompilieren, ohne zu laufen, drücken Sie Um zu starten, ohne erneut zu kompilieren, drücken Sie und zum Kompilieren und Ausführen, drücken Sie .

   Kompilieren und Ausführen der Standardeinstellung "Hallo Welt!" Code ergibt folgendes Ergebnis: