C++
Compilazione e costruzione

introduzione

Osservazioni

Compilare con GCC

Supponendo un singolo file sorgente denominato main.cpp , il comando per compilare e collegare un eseguibile non ottimizzato è il seguente (Compilare senza ottimizzazione è utile per lo sviluppo iniziale e il debug, sebbene -Og sia ufficialmente raccomandato per le nuove versioni di GCC).

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

Per produrre un eseguibile ottimizzato per l'utilizzo in produzione, utilizzare una delle opzioni -O (vedere: -O1 , -O2 , -O3 , -Os , -Ofast ):

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

Se l'opzione -O viene omessa, -O0, che significa nessuna ottimizzazione, viene utilizzata come predefinita (specificando -O senza un numero si risolve in -O1).

In alternativa, utilizzare i flag di ottimizzazione dai gruppi O (o più ottimizzazioni sperimentali) direttamente. Il seguente esempio costruisce con l'ottimizzazione -O2 , più un flag dal livello di ottimizzazione -O3 :

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

Per produrre un eseguibile ottimizzato specifico per piattaforma (da utilizzare nella produzione sulla macchina con la stessa architettura), utilizzare:

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

Uno dei due precedenti produrrà un file binario che può essere eseguito con .\app.exe su Windows e ./app su Linux, Mac OS, ecc.

Il flag -o può anche essere saltato. In questo caso, GCC creerà l'output eseguibile predefinito a.exe su Windows e a.out su sistemi simil-Unix. Per compilare un file senza collegarlo, utilizzare l'opzione -c :

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

Questo produce un file oggetto denominato file.o che può essere successivamente collegato ad altri file per produrre un binario:

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

Ulteriori informazioni sulle opzioni di ottimizzazione sono disponibili su gcc.gnu.org . Di particolare nota sono -Og (ottimizzazione con enfasi sull'esperienza di debug - raccomandata per il ciclo standard edit-compile-debug) e -Ofast (tutte le ottimizzazioni, comprese quelle che ignorano la conformità agli standard rigorosi).

Il flag -Wall abilita gli avvisi per molti errori comuni e deve essere sempre utilizzato. Per migliorare la qualità del codice, spesso è anche consigliato utilizzare -Wextra e altri flag di avviso che non sono automaticamente abilitati da -Wall e -Wextra .

Se il codice prevede uno specifico standard C ++, specificare quale standard utilizzare includendo il flag -std= . I valori supportati corrispondono all'anno di finalizzazione per ciascuna versione dello standard ISO C ++. A partire da GCC 6.1.0, i valori validi per lo std= flag sono c++98 / c++03 , c++11 , c++14 e c++17 / c++1z . I valori separati da una barra diretta sono equivalenti.

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

GCC include alcune estensioni specifiche del compilatore che sono disabilitate quando sono in conflitto con uno standard specificato dal flag -std= . Per compilare con tutte le estensioni abilitate, è possibile utilizzare il valore gnu++XX , dove XX è uno degli anni utilizzati dai valori c++ sopra elencati.

Lo standard predefinito verrà utilizzato se non viene specificato nessuno. Per le versioni di GCC precedenti alla 6.1.0, il valore predefinito è -std=gnu++03 ; in GCC 6.1.0 e -std=gnu++14 , il valore predefinito è -std=gnu++14 .

Si noti che a causa di bug in GCC, il flag -pthread deve essere presente alla compilazione e al collegamento per GCC per supportare la funzionalità di threading standard C ++ introdotta con C ++ 11, come std::thread e std::wait_for . Omettendola quando si usano le funzioni di threading, non si ottengono avvisi ma risultati non validi su alcune piattaforme.

Collegamento con le librerie:

Utilizzare l'opzione -l per passare il nome della libreria:

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

Se la libreria non si trova nel percorso della libreria standard, aggiungere il percorso con l'opzione -L :

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

Le librerie multiple possono essere collegate tra loro:

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

Se una libreria dipende da un'altra, metti la libreria dipendente prima della libreria indipendente:

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

Oppure lascia che il linker determini l'ordinamento stesso tramite --start-group e --end-group (nota: questo ha un costo significativo delle prestazioni):

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

Compilazione con Visual C ++ (riga di comando)

Per i programmatori provenienti da GCC o Clang per Visual Studio, o per i programmatori più a loro agio con la riga di comando in generale, è possibile utilizzare il compilatore Visual C ++ dalla riga di comando e l'IDE.

Se desideri compilare il codice dalla riga di comando in Visual Studio, devi prima configurare l'ambiente della riga di comando. Questa operazione può essere eseguita aprendo il Visual Studio Command Prompt / Visual Studio Command Prompt Developer Command Prompt / Visual Studio Command Prompt Developer Command Prompt x86 Native Tools Command Prompt x64 Native Tools Command Prompt / x86 Native Tools Command Prompt x64 Native Tools Command Prompt o simile (come fornito dalla versione di Visual Studio) oppure, al prompt dei comandi, passando a la sottodirectory VC directory di installazione del compilatore (in genere \Program Files (x86)\Microsoft Visual Studio x\VC , dove x è il numero di versione (come 10.0 per il 2010 o 14.0 per il 2015) ed esegue il file batch VCVARSALL con un parametro della riga di comando specificato qui .

Nota che a differenza di GCC, Visual Studio non fornisce un front-end per il linker ( link.exe ) tramite il compilatore ( cl.exe ), ma fornisce invece il linker come un programma separato, che il compilatore chiama quando esce. cl.exe e link.exe possono essere usati separatamente con diversi file e opzioni, oppure cl può essere detto di passare file e opzioni per link se entrambe le attività sono eseguite insieme. Qualsiasi opzione di collegamento specificata per cl verrà tradotta in opzioni per il link e tutti i file non elaborati da cl verranno passati direttamente al link . Poiché questa è principalmente una semplice guida alla compilazione con la riga di comando di Visual Studio, gli argomenti per il link non verranno descritti in questo momento; se hai bisogno di una lista, guarda qui .

Si noti che gli argomenti da cl sono case-sensitive, mentre gli argomenti da link non lo sono.

[Si noti che alcuni dei seguenti esempi utilizzano la variabile "directory corrente" della shell di Windows, %cd% , quando si specificano i nomi di percorso assoluti. Per chi non ha familiarità con questa variabile, si espande nella directory di lavoro corrente. Dalla riga di comando, sarà la directory in cui ti cl quando hai eseguito cl , e viene specificato nel prompt dei comandi per impostazione predefinita (se il tuo prompt dei comandi è C:\src> , ad esempio, %cd% è C:\src\ ).]

Supponendo che un singolo file sorgente denominato main.cpp nella cartella corrente, il comando per compilare e collegare un eseguibile non ottimizzato (utile per lo sviluppo iniziale e il debug) è (utilizzare uno dei seguenti):

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.

Supponendo un file sorgente aggiuntivo "niam.cpp" nella stessa directory, utilizzare quanto segue:

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

Puoi anche utilizzare i caratteri jolly, come ci si aspetterebbe:

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

Per rinominare o riposizionare l'eseguibile, utilizzare uno dei seguenti:

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

Sia /o che /Fe passano il loro parametro (chiamiamolo o-param ) al link come /OUT:o-param , aggiungendo l'estensione appropriata (generalmente .exe o .dll ) a "nominare" o-param come necessario. Mentre sia /o che /Fe sono a mia conoscenza identiche nella funzionalità, quest'ultimo è preferito per Visual Studio. /o è contrassegnato come deprecato e sembra essere fornito principalmente per i programmatori più familiari con GCC o Clang.

Si noti che mentre lo spazio tra /o e la cartella e / o il nome specificati è facoltativo, non può esserci uno spazio tra /Fe e la cartella e / o il nome specificati.

Allo stesso modo, per produrre un eseguibile ottimizzato (per l'uso in produzione), utilizzare:

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.

Infine, per produrre un eseguibile ottimizzato specifico della piattaforma (da utilizzare nella produzione sulla macchina con l'architettura specificata), selezionare il prompt dei comandi appropriato o il parametro VCVARSALL per la piattaforma di destinazione. link dovrebbe rilevare la piattaforma desiderata dai file oggetto; in caso contrario, utilizzare l' opzione /MACHINE per specificare esplicitamente la piattaforma di destinazione.

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

Qualsiasi dei precedenti produrrà un eseguibile con il nome specificato da /o o /Fe , o se nessuno dei due è fornito, con un nome identico al primo file sorgente o oggetto specificato nel compilatore.

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

Per compilare un file (s) senza collegamento, utilizzare:

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

Questo dice a cl di uscire senza chiamare il link e produce un file oggetto, che può essere successivamente collegato ad altri file per produrre un binario.

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

Ci sono anche altri preziosi parametri da riga di comando, che sarebbe molto utile per gli utenti sapere:

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

Per chiunque abbia più familiarità con i sistemi * nix e / o GCC / Clang, cl , link e altri strumenti da riga di comando di Visual Studio possono accettare parametri specificati con un trattino (come -c ) invece di una barra (come /c ). Inoltre, Windows riconosce una barra o una barra rovesciata come separatore di percorsi valido, quindi è possibile utilizzare anche i percorsi in stile * nix. Ciò semplifica la conversione di semplici righe di comando del compilatore da g++ o clang++ a cl , o viceversa, con modifiche minime.

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

Ovviamente, durante il porting di righe di comando che utilizzano opzioni più complesse di g++ o clang++ , è necessario cercare comandi equivalenti nelle documentazioni del compilatore applicabili e / o nei siti di risorse, ma questo rende più facile iniziare le cose con il minimo tempo speso a conoscere nuovi compilatori.

Nel caso in cui ti occorrono caratteristiche linguistiche specifiche per il tuo codice, è necessaria una versione specifica di MSVC. Da Visual C ++ 2015 Update 3 su di esso è possibile scegliere la versione dello standard da compilare tramite il flag /std . I valori possibili sono /std:c++14 e /std:c++latest ( /std:c++17 seguirà presto).

Nota: nelle versioni precedenti di questo compilatore erano disponibili flag di funzionalità specifiche, tuttavia questo era principalmente utilizzato per le anteprime di nuove funzionalità.

Compilazione con Visual Studio (interfaccia grafica) - Hello World

1. Scarica e installa Visual Studio Community 2015
2. Apri la community di Visual Studio
3. Fare clic su File -> Nuovo -> Progetto
4. Fare clic su Modelli -> Visual C ++ -> Applicazione console Win32 e quindi denominare il progetto MyFirstProgram .
5. Clicca Ok
6. Fare clic su Avanti nella seguente finestra.
7. Seleziona la casella Empty project e quindi fai clic su Fine:
8. Fai clic destro sulla cartella File sorgente quindi -> Aggiungi -> Nuovo elemento:
9. Selezionare il file C ++ e denominare il file main.cpp, quindi fare clic su Aggiungi: 10: Copia e incolla il seguente codice nel nuovo file main.cpp:

#include <iostream>

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

Il tuo ambiente dovrebbe assomigliare a:

11. Fai clic su Debug -> Avvia senza eseguire il debug (o premi ctrl + F5):

12. Fatto. Dovresti ottenere il seguente output della console:

Compilando con Clang

Poiché il front-end di Clang è progettato per essere compatibile con GCC, molti programmi che possono essere compilati tramite GCC verranno compilati quando si scambierà g++ da clang++ negli script di compilazione. Se non viene fornita la -std=version , verrà utilizzato gnu11.

Gli utenti di Windows che sono abituati a MSVC possono scambiare cl.exe con clang-cl.exe . Per impostazione predefinita, clang tenta di essere compatibile con la versione più alta di MSVC che è stata installata.

Nel caso della compilazione con Visual Studio, clang-cl può essere utilizzato modificando il Platform toolset di Platform toolset della Platform toolset nelle proprietà del progetto.

In entrambi i casi, clang è compatibile solo tramite il suo front-end, sebbene cerchi anche di generare file di oggetti binari compatibili. Gli utenti di clang-cl devono tenere presente che la compatibilità con MSVC non è ancora completa .

Per usare clang o clang-cl, si potrebbe usare l'installazione di default su determinate distribuzioni Linux o quelle in bundle con IDE (come XCode su Mac). Per le altre versioni di questo compilatore o su piattaforme che non hanno questo installato, questo può essere scaricato dalla pagina di download ufficiale .

Se stai usando CMake per costruire il tuo codice, in genere puoi cambiare il compilatore impostando le variabili di ambiente CC e CXX questo modo:

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

Vedi anche introduzione a Cmake .

Compilatori online

Vari siti Web forniscono accesso online ai compilatori C ++. Le funzionalità del compilatore online variano in modo significativo da un sito all'altro, ma in genere consentono di eseguire le seguenti operazioni:

• Incolla il tuo codice in un modulo Web nel browser.
• Seleziona alcune opzioni del compilatore e compila il codice.
• Raccogli il compilatore e / o l'output del programma.

Il comportamento del sito Web del compilatore online è in genere piuttosto restrittivo poiché consente a chiunque di eseguire compilatori ed eseguire codice arbitrario sul proprio lato server, mentre l'esecuzione ordinariamente remota di codice arbitrario viene considerata come vulnerabilità.

I compilatori online possono essere utili per i seguenti scopi:

• Esegui un piccolo snippet di codice da una macchina che non ha compilatore C ++ (smartphone, tablet, ecc.).
• Assicurati che il codice venga compilato correttamente con diversi compilatori e funzioni allo stesso modo indipendentemente dal compilatore con cui è stato compilato.
• Impara o insegna le basi del C ++.
• Impara le moderne funzionalità C ++ (C ++ 14 e C ++ 17 nel prossimo futuro) quando il compilatore C ++ aggiornato non è disponibile sul computer locale.
• Trova un bug nel tuo compilatore confrontandolo con una vasta serie di altri compilatori. Controlla se un bug del compilatore è stato corretto nelle versioni future, che non sono disponibili sul tuo computer.
• Risolvi i problemi del giudice online.

Quali compilatori online non dovrebbero essere utilizzati per:

• Sviluppa applicazioni complete (anche piccole) usando C ++. Solitamente i compilatori online non consentono il collegamento con librerie di terze parti o download di artefatti di build.
• Esegui calcoli intensivi. Le risorse di elaborazione sul lato server sono limitate, quindi qualsiasi programma fornito dall'utente verrà ucciso dopo pochi secondi di esecuzione. Il tempo di esecuzione consentito è di solito sufficiente per il test e l'apprendimento.
• Attacca il server di compilazione stesso o qualsiasi host di terze parti in rete.

Esempi:

Dichiarazione di non responsabilità: gli autori della documentazione non sono affiliati con le risorse elencate di seguito. I siti Web sono elencati in ordine alfabetico.

• http://codepad.org/ Compilatore online con condivisione del codice. La modifica del codice dopo la compilazione con un avvertimento o errore del codice sorgente non funziona così bene.
• http://coliru.stacked-crooked.com/ Compilatore online per il quale si specifica la riga di comando. Fornisce entrambi i compilatori GCC e Clang per l'uso.
• http://cpp.sh/ - Compilatore online con supporto per C ++ 14. Non ti permette di modificare la riga di comando del compilatore, ma alcune opzioni sono disponibili tramite i controlli della GUI.
• https://gcc.godbolt.org/ - Fornisce un ampio elenco di versioni del compilatore, architetture e output di disassemblaggio. Molto utile quando è necessario esaminare in che modo viene compilato il codice da diversi compilatori. GCC, Clang, MSVC ( CL ), Intel compiler ( icc ), ELLCC e Zapcc sono presenti, con uno o più di questi compilatori disponibili per ARM, ARMv8 (come ARM64), Atmel AVR, MIPS, MIPS64, MSP430, PowerPC , x86 e x64 architecti. Gli argomenti della riga di comando del compilatore possono essere modificati.
• https://ideone.com/ - Ampiamente utilizzato in rete per illustrare il comportamento del frammento di codice. Fornisce sia GCC e Clang per l'uso, ma non consente di modificare la riga di comando del compilatore.
• http://melpon.org/wandbox - Supporta numerose versioni del compilatore Clang e GNU / GCC.
• http://onlinegdb.com/ - Un IDE estremamente minimalista che include un editor, un compilatore (gcc) e un debugger (gdb).
• http://rextester.com/ - Fornisce compilatori Clang, GCC e Visual Studio per C e C ++ (insieme ai compilatori per altre lingue), con la libreria Boost disponibile per l'uso.
• http://tutorialspoint.com/compile_cpp11_online.php - Una shell UNIX completa con GCC e un esploratore di progetti user-friendly.
• http://webcompiler.cloudapp.net/ - Compilatore di Visual Studio 2015 online, fornito da Microsoft come parte di RiSE4fun.

Il processo di compilazione C ++

Quando sviluppi un programma C ++, il passo successivo è compilare il programma prima di eseguirlo. La compilazione è il processo che converte il programma scritto in un linguaggio leggibile come C, C ++ ecc. In un codice macchina, compreso direttamente dall'unità di elaborazione centrale. Ad esempio, se si ha un file di codice sorgente C ++ denominato prog.cpp e si esegue il comando compile,

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

Ci sono 4 fasi principali coinvolte nella creazione di un file eseguibile dal file sorgente.

1. Il C ++ il preprocessore prende un file di codice sorgente C ++ e tratta le intestazioni (#include), le macro (#define) e altre direttive del preprocessore.

2. Il file di codice sorgente C ++ espanso prodotto dal preprocessore C ++ viene compilato nel linguaggio assembly per la piattaforma.

3. Il codice assembler generato dal compilatore viene assemblato nel codice oggetto per la piattaforma.

4. Il file di codice oggetto prodotto dall'assemblatore è collegato insieme
   con i file di codice oggetto per tutte le funzioni di libreria utilizzate per produrre una libreria o un file eseguibile.

Pre-elaborazione

Il preprocessore gestisce le direttive del preprocessore, come #include e #define. È agnostico della sintassi del C ++, motivo per cui deve essere usato con cautela.

Funziona su un file sorgente C ++ alla volta sostituendo le direttive #include con il contenuto dei rispettivi file (che di solito è solo dichiarazioni), sostituendo le macro (#define) e selezionando porzioni di testo diverse a seconda di #if, direttive #ifdef e #ifndef.

Il preprocessore funziona su un flusso di token di preelaborazione. La sostituzione delle macro è definita come sostituzione di token con altri token (l'operatore ## consente di unire due token quando ha senso).

Dopo tutto ciò, il preprocessore produce un singolo output che è un flusso di token risultante dalle trasformazioni descritte sopra. Aggiunge anche alcuni marcatori speciali che dicono al compilatore da dove proviene ogni riga in modo che possa usare quelli per produrre messaggi di errore sensibili.

Alcuni errori possono essere prodotti in questa fase con un uso intelligente delle direttive #if e #error.

Usando il flag sotto il compilatore, possiamo fermare il processo in fase di pre-elaborazione.

g++ -E prog.cpp

Compilazione

La fase di compilazione viene eseguita su ciascun output del preprocessore. Il compilatore analizza il codice sorgente C ++ puro (ora senza alcuna direttiva preprocessore) e lo converte in codice assembly. Quindi richiama il back-end sottostante (assemblatore in toolchain) che assembla quel codice in codice macchina producendo un file binario effettivo in qualche formato (ELF, COFF, a.out, ...). Questo file oggetto contiene il codice compilato (in forma binaria) dei simboli definiti nell'input. I simboli nei file oggetto sono indicati per nome.

I file oggetto possono fare riferimento a simboli che non sono definiti. Questo è il caso quando si usa una dichiarazione e non si fornisce una definizione per essa. Il compilatore non si preoccupa di questo, e produrrà felicemente il file oggetto finché il codice sorgente è ben formato.

I compilatori di solito ti permettono di interrompere la compilazione a questo punto. Questo è molto utile perché con esso puoi compilare ogni file del codice sorgente separatamente. Il vantaggio che offre è che non è necessario ricompilare tutto se si modifica solo un singolo file.

I file oggetto prodotti possono essere inseriti in archivi speciali chiamati librerie statiche, per un riutilizzo più semplice in seguito.

È in questa fase che vengono riportati errori di compilazione "regolari", come errori di sintassi o errori di risoluzione del sovraccarico non riusciti.

Per interrompere il processo dopo la fase di compilazione, possiamo usare l'opzione -S:

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

assemblaggio

L'assemblatore crea codice oggetto. Su un sistema UNIX è possibile visualizzare file con suffisso .o (.OBJ su MSDOS) per indicare i file di codice oggetto. In questa fase l'assemblatore converte i file oggetto dal codice assembly in istruzioni a livello macchina e il file creato è un codice oggetto rilocabile. Quindi, la fase di compilazione genera il programma oggetto rilocabile e questo programma può essere utilizzato in luoghi diversi senza doverlo compilare nuovamente.

Per interrompere il processo dopo la fase di assemblaggio, è possibile utilizzare l'opzione -c:

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

Collegamento

Il linker è ciò che produce l'output finale della compilazione dai file oggetto prodotti dall'assemblatore. Questo output può essere una libreria condivisa (o dinamica) (e mentre il nome è simile, non hanno molto in comune con le librerie statiche menzionate in precedenza) o un eseguibile.

Collega tutti i file oggetto sostituendo i riferimenti a simboli non definiti con gli indirizzi corretti. Ognuno di questi simboli può essere definito in altri file oggetto o nelle librerie. Se sono definiti in librerie diverse dalla libreria standard, è necessario comunicarlo al linker.

In questa fase gli errori più comuni mancano di definizioni o definizioni duplicate. Il primo significa che le definizioni non esistono (cioè non sono scritte), o che i file oggetto o le librerie in cui risiedono non sono stati dati al linker. Quest'ultima è ovvia: lo stesso simbolo è stato definito in due diversi file o librerie di oggetti.

Compilazione con codice :: Blocchi (interfaccia grafica)

1. Scarica e installa il codice :: Blocchi qui . Se sei su Windows, fai attenzione a selezionare un file per il quale il nome contiene mingw , gli altri file non installano alcun compilatore.

2. Apri codice :: Blocchi e fai clic su "Crea un nuovo progetto":

   

3. Seleziona "Applicazione console" e fai clic su "Vai":

   

4. Fare clic su "Avanti", selezionare "C ++", fare clic su "Avanti", selezionare un nome per il progetto e scegliere una cartella in cui salvarlo, fare clic su "Avanti" e quindi fare clic su "Fine".

5. Ora puoi modificare e compilare il tuo codice. Un codice predefinito che stampa "Hello world!" nella console è già lì. Per compilare e / o eseguire il tuo programma, premi uno dei tre pulsanti di compilazione / esecuzione nella barra degli strumenti:

   

   Per compilare senza correre, premere , per eseguire senza compilare di nuovo, premere e per compilare e quindi eseguire, premere .

   Compilazione ed esecuzione del predefinito "Hello world!" il codice dà il seguente risultato: