C++
Compileren en bouwen

Invoering

Opmerkingen

Compileren met GCC

Uitgaande van een enkel bronbestand met de naam main.cpp , is de opdracht om een niet-geoptimaliseerd uitvoerbaar bestand te compileren en te koppelen als volgt (compileren zonder optimalisatie is handig voor initiële ontwikkeling en foutopsporing, hoewel -Og officieel wordt aanbevolen voor nieuwere GCC-versies).

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

Gebruik een van de opties -O om een geoptimaliseerd uitvoerbaar bestand te produceren voor gebruik in productie (zie: -O1 , -O2 , -O3 , -Os , -Ofast ):

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

Als de optie -O wordt weggelaten, wordt -O0, wat geen optimalisaties betekent, standaard gebruikt (als u -O opgeeft zonder een getal, wordt dit omgezet in -O1).

U kunt ook rechtstreeks optimalisatievlaggen uit de O groepen (of meer experimentele optimalisaties) gebruiken. Het volgende voorbeeld bouwt met -O2 optimalisatie, plus één vlag van het -O3 optimalisatieniveau:

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

Om een platformspecifiek geoptimaliseerd uitvoerbaar bestand te produceren (voor gebruik bij productie op de machine met dezelfde architectuur), gebruikt u:

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

Elk van de bovenstaande levert een binair bestand op dat kan worden uitgevoerd met .\app.exe op Windows en ./app op Linux, Mac OS, enz.

De vlag -o kan ook worden overgeslagen. In dit geval maakt GCC standaard uitvoerbaar uitvoerbaar bestand a.exe op Windows en a.out op Unix-achtige systemen. Gebruik de optie -c om een bestand te compileren zonder het te koppelen:

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

Dit produceert een objectbestand met de naam file.o dat later kan worden gekoppeld aan andere bestanden om een binair bestand te produceren:

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

Meer over optimalisatie-opties is te vinden op gcc.gnu.org . Van bijzonder belang zijn -Og (optimalisatie met de nadruk op debugging-ervaring - aanbevolen voor de standaard edit-compile-debug-cyclus) en -Ofast (alle optimalisaties, inclusief die waarbij strikte naleving van normen wordt genegeerd).

De vlag -Wall waarschuwt voor veel voorkomende fouten en moet altijd worden gebruikt. Om de kwaliteit van de code te verbeteren, wordt het vaak ook aangemoedigd om -Wextra en andere waarschuwingsvlaggen te gebruiken die niet automatisch worden ingeschakeld door -Wall en -Wextra .

Als de code een specifieke C ++ standaard verwacht, geeft u op welke standaard moet worden gebruikt door de vlag -std= . Ondersteunde waarden komen overeen met het jaar van voltooiing voor elke versie van de ISO C ++ standaard. Vanaf GCC 6.1.0 zijn de geldige waarden voor de std= vlag c++98 / c++03 , c++11 , c++14 en c++17 / c++1z . Waarden gescheiden door een schuine streep zijn equivalent.

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

GCC bevat enkele compilerspecifieke extensies die zijn uitgeschakeld wanneer ze conflicteren met een standaard die wordt opgegeven door de vlag -std= . Om te compileren met alle ingeschakelde extensies, kan de waarde gnu++XX worden gebruikt, waarbij XX een van de jaren is die worden gebruikt door de hierboven genoemde c++ waarden.

De standaardstandaard wordt gebruikt als er geen is opgegeven. Voor versies van GCC vóór 6.1.0 is de standaardinstelling -std=gnu++03 ; in GCC 6.1.0 en hoger is de standaard -std=gnu++14 .

Merk op dat vanwege bugs in GCC de -pthread vlag aanwezig moet zijn bij het compileren en koppelen voor GCC ter ondersteuning van de standaard C ++ threading-functionaliteit geïntroduceerd met C ++ 11, zoals std::thread en std::wait_for . Het weglaten bij gebruik van threading-functies kan op sommige platforms geen waarschuwingen maar ongeldige resultaten tot gevolg hebben.

Linken met bibliotheken:

Gebruik de optie -l om de naam van de bibliotheek door te geven:

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

Als de bibliotheek zich niet in het standaardbibliotheekpad bevindt, voegt u het pad met de optie -L :

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

Meerdere bibliotheken kunnen aan elkaar worden gekoppeld:

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

Als de ene bibliotheek van een andere afhankelijk is, plaatst u de afhankelijke bibliotheek voor de onafhankelijke bibliotheek:

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

Of laat de linker de volgorde zelf bepalen via --start-group en --end-group (let op: dit heeft aanzienlijke prestatiekosten):

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

Compileren met Visual C ++ (opdrachtregel)

Voor programmeurs die van GCC of Clang naar Visual Studio komen, of programmeurs die meer vertrouwd zijn met de opdrachtregel in het algemeen, kunt u de Visual C ++ compiler vanaf de opdrachtregel en de IDE gebruiken.

Als u uw code vanaf de opdrachtregel in Visual Studio wilt compileren, moet u eerst de opdrachtregelomgeving instellen. Dit kan worden gedaan door de Visual Studio Command Prompt / Developer Command Prompt / x86 Native Tools Command Prompt / x64 Native Tools Command Prompt of iets dergelijks (zoals verstrekt door uw versie van Visual Studio) te openen, of bij de opdrachtprompt, door te navigeren naar de VC submap van de installatiemap van de compiler (meestal \Program Files (x86)\Microsoft Visual Studio x\VC , waarbij x het versienummer is (zoals 10.0 voor 2010 of 14.0 voor 2015) en het batchbestand VCVARSALL uitgevoerd met een opdrachtregelparameter hier opgegeven.

Merk op dat Visual Studio, anders dan GCC, geen front-end voor de linker ( link.exe ) biedt via de compiler ( cl.exe ), maar in plaats daarvan de linker als een afzonderlijk programma cl.exe , dat de compiler aanroept wanneer deze wordt afgesloten. cl.exe en link.exe kunnen afzonderlijk worden gebruikt met verschillende bestanden en opties, of cl kan worden verteld bestanden en link als beide taken samen worden uitgevoerd. Alle koppelingsopties die zijn opgegeven voor cl worden vertaald in opties voor link en alle bestanden die niet door cl worden verwerkt, worden direct aan de link doorgegeven. Aangezien dit voornamelijk een eenvoudige handleiding is voor het compileren met de Visual Studio-opdrachtregel, worden argumenten voor een link op dit moment niet beschreven; als u een lijst nodig hebt, kijk hier .

Merk op dat argumenten voor cl hoofdlettergevoelig zijn, argumenten voor link niet.

[Houd er rekening mee dat sommige van de volgende voorbeelden de variabele "huidige map" van de Windows-shell, %cd% , gebruiken bij het opgeven van absolute padnamen. Voor iedereen die niet bekend is met deze variabele, wordt deze uitgebreid naar de huidige werkmap. Vanaf de opdrachtregel is dit de map waarin u zich cl toen u cl en wordt standaard opgegeven in de opdrachtprompt (als uw opdrachtprompt bijvoorbeeld C:\src> is, is %cd% C:\src\ ).]

Uitgaande van een enkel bronbestand met de naam main.cpp in de huidige map, is de opdracht om een niet-geoptimaliseerd uitvoerbaar bestand te compileren en te koppelen (handig voor initiële ontwikkeling en foutopsporing) (gebruik een van de volgende):

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.

Uitgaande van een extra bronbestand "niam.cpp" in dezelfde map, gebruikt u het volgende:

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".

Je kunt ook jokertekens gebruiken, zoals je zou verwachten:

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".

Gebruik een van de volgende opties om het uitvoerbare bestand te hernoemen of te verplaatsen:

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".

Zowel /o als /Fe geven hun parameter door (laten we het o-param noemen) om te link als /OUT:o-param , waarbij de juiste extensie (meestal .exe of .dll ) wordt toegevoegd aan o-param als dat nodig is. Hoewel beide /o en /Fe naar mijn weten identiek zijn qua functionaliteit, heeft laatstgenoemde de voorkeur voor Visual Studio. /o is gemarkeerd als verouderd en lijkt vooral te worden aangeboden aan programmeurs die meer bekend zijn met GCC of Clang.

Merk op dat hoewel de ruimte tussen /o en de opgegeven map en / of naam optioneel is, er geen spatie tussen /Fe en de opgegeven map en / of naam kan zijn.

Om een geoptimaliseerd uitvoerbaar bestand te produceren (voor gebruik in productie), gebruikt u op dezelfde manier:

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.

Om ten slotte een platformspecifiek geoptimaliseerd uitvoerbaar bestand te produceren (voor gebruik in productie op de machine met de opgegeven architectuur), kiest u de juiste opdrachtprompt of de parameter VCVARSALL voor het doelplatform. link moet het gewenste platform uit de objectbestanden detecteren; zo niet, gebruik dan de optie /MACHINE om het doelplatform expliciet op te geven.

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

Al het bovenstaande zal een uitvoerbaar bestand produceren met de naam opgegeven door /o of /Fe , of als geen van beide wordt verstrekt, met een naam die identiek is aan de eerste bron of objectbestand dat is opgegeven voor de compiler.

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".

Gebruik het volgende om een bestand (en) te compileren zonder te koppelen:

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

Dit vertelt cl om af te sluiten zonder link aan te roepen, en produceert een objectbestand, dat later kan worden gekoppeld aan andere bestanden om een binair bestand te produceren.

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".

Er zijn ook andere waardevolle opdrachtregelparameters, die voor gebruikers zeer nuttig zouden zijn om te weten:

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).

Iedereen die meer bekend is met * nix-systemen en / of GCC / Clang, cl , link en andere Visual Studio-opdrachtregelprogramma's kunnen parameters accepteren die zijn opgegeven met een koppelteken (zoals -c ) in plaats van een schuine streep (zoals /c ). Bovendien herkent Windows een schuine streep of een backslash als een geldig padscheidingsteken, zodat ook paden in * nix-stijl kunnen worden gebruikt. Dit maakt het eenvoudig om eenvoudige compiler-opdrachtregels van g++ of clang++ naar cl te converteren, of omgekeerd, met minimale wijzigingen.

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

Natuurlijk moet u bij het porteren van opdrachtregels die meer complexe g++ of clang++ -opties gebruiken, equivalente opdrachten opzoeken in de toepasselijke compilerdocumentatie en / of op resource-sites, maar dit maakt het eenvoudiger om dingen te beginnen met minimale tijd besteed aan leren over nieuwe compilers.

Als u specifieke taalfuncties nodig hebt voor uw code, was een specifieke release van MSVC vereist. Vanaf Visual C ++ 2015 Update 3 is het mogelijk om de versie van de standaard te kiezen om mee te compileren via de /std vlag. Mogelijke waarden zijn /std:c++14 en /std:c++latest ( /std:c++17 volgt binnenkort).

Opmerking: in oudere versies van deze compiler waren specifieke functievlaggen beschikbaar, maar deze werden meestal gebruikt voor previews van nieuwe functies.

Compileren met Visual Studio (grafische interface) - Hallo wereld

1. Download en installeer Visual Studio Community 2015
2. Open Visual Studio Community
3. Klik op Bestand -> Nieuw -> Project
4. Klik op Sjablonen -> Visual C ++ -> Win32 Console Application en noem het project MyFirstProgram .
5. Klik OK
6. Klik in het volgende venster op Volgende.
7. Vink het vakje Empty project en klik vervolgens op Voltooien:
8. Klik met de rechtermuisknop op de map Bronbestand en vervolgens -> Toevoegen -> Nieuw item:
9. Selecteer C ++ -bestand en geef het bestand main.cpp een naam en klik vervolgens op Toevoegen: 10: Kopieer en plak de volgende code in het nieuwe bestand main.cpp:

#include <iostream>

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

Je omgeving moet er uitzien als:

11. Klik op Debug -> Start Without Debugging (of druk op Ctrl + F5):

12. Gedaan. U zou de volgende console-uitvoer moeten krijgen:

Compileren met Clang

Aangezien de Clang front-end is ontworpen om compatibel te zijn met GCC, zullen de meeste programma's die kunnen worden gecompileerd via GCC worden gecompileerd wanneer u g++ door clang++ in de build-scripts ruilt. Als er geen -std=version wordt gegeven, wordt gnu11 gebruikt.

Windows-gebruikers die gewend zijn aan MSVC kunnen cl.exe omwisselen met cl.exe clang-cl.exe . Standaard probeert clang compatibel te zijn met de hoogste versie van MSVC die is geïnstalleerd.

In het geval van compileren met Visual Studio, kan clang-cl worden gebruikt door de Platform toolset in de projecteigenschappen te wijzigen.

In beide gevallen is clang alleen compatibel via zijn front-end, hoewel het ook probeert om binair compatibele objectbestanden te genereren. Gebruikers van clang-cl moeten er rekening mee houden dat de compatibiliteit met MSVC nog niet is voltooid .

Om clang of clang-cl te gebruiken, zou men de standaardinstallatie op bepaalde Linux-distributies of die met IDE's (zoals XCode op Mac) kunnen gebruiken. Voor andere versies van deze compiler of op platforms waarop dit niet is geïnstalleerd, kan dit worden gedownload van de officiële downloadpagina .

Als u CMake gebruikt om uw code te bouwen, kunt u meestal de compiler schakelen door de omgevingsvariabelen CC en CXX als volgt in te stellen:

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

Zie ook inleiding tot Cmake .

Online compilers

Verschillende websites bieden online toegang tot C ++ -compilers. De functieset van de online compiler varieert aanzienlijk van site tot site, maar meestal kunnen ze het volgende doen:

• Plak uw code in een webformulier in de browser.
• Selecteer enkele compileropties en compileer de code.
• Verzamel compiler en / of programma-output.

Het gedrag van de online compilerwebsite is meestal vrij beperkend, omdat ze iedereen in staat stellen compilers uit te voeren en willekeurige code op hun server uit te voeren, terwijl het uitvoeren van externe willekeurige code doorgaans als kwetsbaarheid wordt beschouwd.

Online compilers kunnen nuttig zijn voor de volgende doeleinden:

• Voer een klein codefragment uit vanaf een computer zonder C ++ -compiler (smartphones, tablets, enz.).
• Zorg ervoor dat code succesvol wordt gecompileerd met verschillende compilers en op dezelfde manier wordt uitgevoerd, ongeacht de compiler waarmee het is gecompileerd.
• Leer of onderricht de basis van C ++.
• Leer moderne C ++ -functies (C ++ 14 en C ++ 17 in de nabije toekomst) wanneer de up-to-date C ++ compiler niet beschikbaar is op de lokale machine.
• Zoek een bug in uw compiler in vergelijking met een groot aantal andere compilers. Controleer of een compileerprobleem is opgelost in toekomstige versies, die niet beschikbaar zijn op uw machine.
• Los online rechterproblemen op.

Waarvoor dienen online compilers niet te worden gebruikt:

• Ontwikkel complete (zelfs kleine) applicaties met C ++. Meestal staan online compilers niet toe om te linken met externe bibliotheken of om artefacten te downloaden.
• Voer intensieve berekeningen uit. Sever-side computerbronnen zijn beperkt, dus elk door de gebruiker verstrekt programma zal na een paar seconden van uitvoering worden gedood. De toegestane uitvoeringstijd is meestal voldoende voor testen en leren.
• Val de compilerserver zelf of andere hosts op het net aan.

Voorbeelden:

Disclaimer: documentatie-auteur (s) zijn niet verbonden met onderstaande bronnen. Websites worden alfabetisch weergegeven.

• http://codepad.org/ Online compiler met code-sharing. Het bewerken van code na het compileren met een broncodewaarschuwing of -fout werkt niet zo goed.
• http://coliru.stacked-crooked.com/ Online compiler waarvoor u de opdrachtregel opgeeft. Biedt zowel GCC- als Clang-compilers voor gebruik.
• http://cpp.sh/ - Online compiler met ondersteuning voor C ++ 14. Hiermee kunt u de opdrachtregel van de compiler niet bewerken, maar sommige opties zijn beschikbaar via GUI-besturingselementen.
• https://gcc.godbolt.org/ - Biedt een brede lijst met compilerversies, architecturen en demontage-uitvoer. Zeer handig wanneer u moet inspecteren waar uw code door verschillende compilers in is gecompileerd. GCC, Clang, MSVC ( CL ), Intel-compiler ( icc ), ELLCC en Zapcc zijn aanwezig, met een of meer van deze compilers beschikbaar voor de ARM, ARMv8 (als ARM64), Atmel AVR, MIPS, MIPS64, MSP430, PowerPC , x86 en x64 architecutres. Compiler-opdrachtregelargumenten kunnen worden bewerkt.
• https://ideone.com/ - Veel gebruikt op internet om gedrag van codefragmenten te illustreren. Biedt zowel GCC als Clang voor gebruik, maar staat u niet toe om de opdrachtregel van de compiler te bewerken.
• http://melpon.org/wandbox - Ondersteunt verschillende Clang- en GNU / GCC-compilerversies.
• http://onlinegdb.com/ - Een extreem minimalistische IDE met een editor, een compiler (gcc) en een debugger (gdb).
• http://rextester.com/ - Biedt Clang-, GCC- en Visual Studio-compilers voor zowel C als C ++ (samen met compilers voor andere talen), met de Boost-bibliotheek beschikbaar voor gebruik.
• http://tutorialspoint.com/compile_cpp11_online.php - Volledige UNIX-shell met GCC en een gebruikersvriendelijke projectverkenner.
• http://webcompiler.cloudapp.net/ - Online Visual Studio 2015-compiler, aangeboden door Microsoft als onderdeel van RiSE4fun.

Het compilatieproces van C ++

Wanneer u een C ++ -programma ontwikkelt, moet u het programma compileren voordat u het uitvoert. De compilatie is het proces dat het programma converteert geschreven in voor mensen leesbare taal zoals C, C ++ enz. Naar een machinecode, direct begrepen door de Centrale Verwerkingseenheid. Als u bijvoorbeeld een C ++ broncodebestand met de naam prog.cpp hebt en u voert de compileeropdracht uit,

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

Er zijn 4 hoofdfasen betrokken bij het maken van een uitvoerbaar bestand uit het bronbestand.

1. De C ++ de preprocessor neemt een C ++ broncodebestand en behandelt de headers (#include), macro's (#define) en andere preprocessorrichtlijnen.

2. Het uitgebreide C ++ broncodebestand geproduceerd door de C ++ preprocessor is gecompileerd in de montagetaal voor het platform.

3. De assemblercode gegenereerd door de compiler wordt geassembleerd in de objectcode voor het platform.

4. Het objectcodebestand geproduceerd door de assembler is aan elkaar gekoppeld
   met de objectcodebestanden voor alle bibliotheekfuncties die worden gebruikt om een bibliotheek of een uitvoerbaar bestand te produceren.

preprocessing

De preprocessor verwerkt de richtlijnen van de preprocessor, zoals #include en #define. Het is agnostisch voor de syntaxis van C ++, daarom moet het met zorg worden gebruikt.

Het werkt op één C ++ bronbestand tegelijk door #include richtlijnen te vervangen door de inhoud van de respectieve bestanden (meestal gewoon aangiftes), het vervangen van macro's (#define) en het selecteren van verschillende delen tekst afhankelijk van #if, #ifdef en #ifndef richtlijnen.

De preprocessor werkt op een stroom preprocessing-tokens. Macrosubstitutie wordt gedefinieerd als het vervangen van tokens door andere tokens (de operator ## maakt het samenvoegen van twee tokens mogelijk wanneer dit logisch is).

Na dit alles produceert de preprocessor een enkele output die een stroom tokens is die het resultaat is van de hierboven beschreven transformaties. Het voegt ook enkele speciale markeringen toe die de compiler vertellen waar elke regel vandaan kwam, zodat deze deze kan gebruiken om verstandige foutmeldingen te produceren.

Sommige fouten kunnen in dit stadium worden geproduceerd met slim gebruik van de richtlijnen #if en #error.

Door de onderstaande compilatievlag te gebruiken, kunnen we het proces in de voorbereidingsfase stoppen.

g++ -E prog.cpp

Compilatie

De compilatiestap wordt uitgevoerd op elke uitgang van de preprocessor. De compiler parseert de pure C ++ broncode (nu zonder preprocessorrichtlijnen) en converteert deze naar assemblagecode. Roept vervolgens het onderliggende back-end (assembler in toolchain) op dat die code assembleert tot machinecode die daadwerkelijk een binair bestand in een bepaald formaat produceert (ELF, COFF, a.out, ...). Dit objectbestand bevat de gecompileerde code (in binaire vorm) van de symbolen die in de invoer zijn gedefinieerd. Symbolen in objectbestanden worden bij naam genoemd.

Objectbestanden kunnen verwijzen naar symbolen die niet zijn gedefinieerd. Dit is het geval wanneer u een aangifte gebruikt en er geen definitie voor geeft. De compiler vindt dit niet erg en zal het objectbestand graag produceren zolang de broncode goed is gevormd.

Met compilers kunt u op dit punt meestal stoppen met compileren. Dit is erg handig omdat u hiermee elk broncodebestand afzonderlijk kunt compileren. Het voordeel hiervan is dat u niet alles opnieuw hoeft te compileren als u slechts één bestand wijzigt.

De geproduceerde objectbestanden kunnen in speciale archieven worden geplaatst, statische bibliotheken genoemd, zodat ze later gemakkelijker kunnen worden hergebruikt.

Het is in dit stadium dat "normale" compilerfouten, zoals syntaxisfouten of mislukte oplossingen voor overbelastingsresolutie, worden gemeld.

Om het proces na de compilatiestap te stoppen, kunnen we de optie -S gebruiken:

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

in elkaar zetten

De assembler maakt objectcode. Op een UNIX-systeem ziet u mogelijk bestanden met een .o-achtervoegsel (.OBJ op MSDOS) om objectcodebestanden aan te geven. In deze fase converteert de assembler die objectbestanden van assemblagecode naar instructies op machineniveau en het gecreëerde bestand is een verplaatsbare objectcode. Daarom genereert de compilatiefase het verplaatsbare objectprogramma en dit programma kan op verschillende plaatsen worden gebruikt zonder opnieuw te hoeven compileren.

Om het proces na de assemblagestap te stoppen, kunt u de optie -c gebruiken:

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

Linken

De linker is wat de uiteindelijke compilatie-uitvoer produceert van de objectbestanden die de assembler produceerde. Deze uitvoer kan een gedeelde (of dynamische) bibliotheek zijn (en hoewel de naam vergelijkbaar is, hebben ze niet veel gemeen met eerder genoemde statische bibliotheken) of een uitvoerbaar bestand.

Het koppelt alle objectbestanden door de verwijzingen naar ongedefinieerde symbolen te vervangen door de juiste adressen. Elk van deze symbolen kan worden gedefinieerd in andere objectbestanden of in bibliotheken. Als ze zijn gedefinieerd in andere bibliotheken dan de standaardbibliotheek, moet u de linker hierover informeren.

In dit stadium zijn de meest voorkomende fouten ontbrekende definities of dubbele definities. Het eerste betekent dat de definities niet bestaan (dat wil zeggen dat ze niet zijn geschreven), of dat de objectbestanden of bibliotheken waar ze zich bevinden niet aan de linker zijn gegeven. Het laatste is duidelijk: hetzelfde symbool werd gedefinieerd in twee verschillende objectbestanden of bibliotheken.

Compileren met code :: blokken (grafische interface)

1. Download en installeer Code :: Blokken hier . Als u Windows gebruikt, moet u een bestand selecteren waarvan de naam mingw bevat, de andere bestanden installeren geen compiler.

2. Open Code :: Blokken en klik op "Maak een nieuw project":

   

3. Selecteer "Console-applicatie" en klik op "Go":

   

4. Klik op "Volgende", selecteer "C ++", klik op "Volgende", selecteer een naam voor uw project en kies een map om het in op te slaan, klik op "Volgende" en klik vervolgens op "Voltooien".

5. Nu kunt u uw code bewerken en compileren. Een standaardcode die "Hallo wereld!" in de console is er al. Om uw programma te compileren en / of uit te voeren, drukt u op een van de drie compileer / start-knoppen op de werkbalk:

   

   Druk op om te compileren zonder uit te voeren , om te draaien zonder opnieuw te compileren, drukt u op en om te compileren en vervolgens uit te voeren, drukt u op .

   Het compileren en uitvoeren van de standaard "Hallo wereld!" code geeft het volgende resultaat: