C++
Compiler et construire

Introduction

Remarques

Compiler avec GCC

En supposant un fichier source unique nommé main.cpp , la commande pour compiler et lier un exécutable non optimisé est la suivante (Compiler sans optimisation est utile pour le développement initial et le débogage, bien que -Og soit officiellement recommandé pour les nouvelles versions de GCC).

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

Pour produire un exécutable optimisé à utiliser en production, utilisez l’une des options -O (voir: -O1 , -O2 , -O3 , -Os , -Ofast ):

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

Si l'option -O est omise, -O0, ce qui signifie aucune optimisation, est utilisé par défaut (en spécifiant -O sans nombre, le résultat est -O1).

Vous pouvez également utiliser directement les indicateurs d'optimisation des groupes O (ou des optimisations plus expérimentales). L'exemple suivant -O2 avec l'optimisation -O2 , plus un indicateur du niveau d'optimisation -O3 :

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

Pour produire un exécutable optimisé spécifique à la plateforme (à utiliser en production sur la machine avec la même architecture), utilisez:

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

L'un ou l'autre des éléments ci-dessus produira un fichier binaire pouvant être exécuté avec .\app.exe sous Windows et ./app sous Linux, Mac OS, etc.

L'indicateur -o peut également être ignoré. Dans ce cas, GCC créera le fichier exécutable par défaut a.exe sur Windows et a.out sur les systèmes de type Unix. Pour compiler un fichier sans le lier, utilisez l'option -c :

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

Cela produit un fichier objet nommé file.o qui peut ensuite être lié à d’autres fichiers pour produire un fichier binaire:

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

Vous trouverez plus d'informations sur les options d'optimisation sur gcc.gnu.org . On notera en particulier -Og (optimisation mettant l'accent sur l'expérience de débogage - recommandée pour le cycle standard de modification-compilation-débogage) et -Ofast (toutes les optimisations, y compris celles ne respectant pas la stricte conformité aux normes).

L'indicateur -Wall active des avertissements pour de nombreuses erreurs courantes et doit toujours être utilisé. Pour améliorer la qualité du code , il est souvent aussi encouragé à utiliser -Wextra et d' autres drapeaux d'avertissement qui ne sont pas activés automatiquement par -Wall et -Wextra .

Si le code attend un standard C ++ spécifique, spécifiez le standard à utiliser en incluant l' -std= . Les valeurs prises en charge correspondent à l'année de finalisation pour chaque version du standard ISO C ++. A partir de GCC 6.1.0, les valeurs valides pour le drapeau std= sont c++98 / c++03 , c++11 , c++14 et c++17 / c++1z . Les valeurs séparées par une barre oblique sont équivalentes.

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

GCC inclut des extensions spécifiques au compilateur désactivées lorsqu'elles sont en conflit avec une norme spécifiée par l' -std= . Pour compiler avec toutes les extensions activées, la valeur gnu++XX peut être utilisée, où XX est l'une des années utilisées par les valeurs c++ mentionnées ci-dessus.

Le standard par défaut sera utilisé si aucun n'est spécifié. Pour les versions de GCC antérieures à 6.1.0, la valeur par défaut est -std=gnu++03 ; dans GCC 6.1.0 et supérieur, la valeur par défaut est -std=gnu++14 .

Notez qu'en raison de bogues dans GCC, l'indicateur -pthread doit être présent lors de la compilation et de la liaison pour que GCC prenne en charge la fonctionnalité de thread standard C ++ introduite avec C ++ 11, telle que std::thread et std::wait_for . L'omettre lors de l'utilisation des fonctions de threading peut entraîner aucun avertissement mais des résultats non valides sur certaines plates-formes.

Liaison avec les bibliothèques:

Utilisez l'option -l pour passer le nom de la bibliothèque:

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

Si la bibliothèque ne se trouve pas dans le chemin de la bibliothèque standard, ajoutez le chemin avec l'option -L :

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

Plusieurs bibliothèques peuvent être liées entre elles:

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

Si une bibliothèque dépend d'une autre, placez la bibliothèque dépendante avant la bibliothèque indépendante:

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

Ou laissez l'éditeur de liens déterminer lui --start-group même l'ordre via --start-group et --end-group (remarque: cela a un coût de performance significatif):

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

Compilation avec Visual C ++ (ligne de commande)

Pour les programmeurs venant de GCC ou Clang vers Visual Studio ou les programmeurs plus à l'aise avec la ligne de commande en général, vous pouvez utiliser le compilateur Visual C ++ à partir de la ligne de commande ainsi que l'EDI.

Si vous souhaitez compiler votre code à partir de la ligne de commande dans Visual Studio, vous devez d'abord configurer l'environnement de ligne de commande. Cela peut être effectué en ouvrant l' Visual Studio Command Prompt / l' Visual Studio Command Prompt Developer Command Prompt / l' Visual Studio Command Prompt Developer Command Prompt x86 Native Tools Command Prompt / l' Developer Command Prompt x86 Native Tools Command Prompt x64 Native Tools Command Prompt ou similaire (fournie par votre version de Visual Studio) ou à l'invite de commande. le sous-répertoire VC répertoire d'installation du compilateur (généralement \Program Files (x86)\Microsoft Visual Studio x\VC , où x est le numéro de version (tel que 10.0 pour 2010 ou 14.0 pour 2015) et exécute le fichier de commandes VCVARSALL avec un paramètre de ligne de commande spécifié ici .

Notez que contrairement à GCC, Visual Studio ne fournit pas de front-end pour l'éditeur de liens ( link.exe ) via le compilateur ( cl.exe ), mais fournit l'éditeur de liens en tant que programme distinct, appelé par le compilateur à sa sortie. cl.exe et link.exe peuvent être utilisés séparément avec différents fichiers et options, ou cl peut transmettre des fichiers et des options à link si les deux tâches sont effectuées ensemble. Toutes les options de liaison spécifiées pour cl seront converties en options de link , et tous les fichiers non traités par cl seront transmis directement au link . Comme il s'agit principalement d'un guide simple de compilation avec la ligne de commande Visual Studio, les arguments pour le link ne seront pas décrits pour le moment; si vous avez besoin d'une liste, voir ici .

Notez que les arguments de cl sont sensibles à la casse, alors que les arguments à link ne le sont pas.

[Soyez averti que certains des exemples suivants utilisent la variable "Répertoire actuel" du shell Windows, %cd% , lors de la spécification des noms de chemin absolus. Pour toute personne peu familière avec cette variable, elle se développe dans le répertoire de travail en cours. À partir de la ligne de commande, ce sera le répertoire dans lequel vous vous trouviez lorsque vous avez exécuté cl , et est spécifié par défaut dans l'invite de commande (si votre invite de commande est C:\src> , par exemple, %cd% est C:\src\ ).]

En supposant qu'un fichier source unique nommé main.cpp dans le dossier en cours, la commande permettant de compiler et de lier un exécutable non optimisé (utile pour le développement initial et le débogage) est (utilisez l'une des méthodes suivantes):

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.

En supposant un fichier source supplémentaire "niam.cpp" dans le même répertoire, utilisez ce qui suit:

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

Vous pouvez également utiliser des caractères génériques, comme on peut s'y attendre:

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

Pour renommer ou déplacer l'exécutable, utilisez l'une des options suivantes:

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

Les deux /o et /Fe passent leur paramètre (appelons - le o-param ) pour link comme /OUT:o-param , annexant l'extension appropriée (généralement .exe ou .dll ) au "nom" o-param s au besoin. Alors que /o et /Fe sont à ma connaissance identiques en termes de fonctionnalités, ce dernier est préféré pour Visual Studio. /o est marqué comme obsolète, et semble être principalement fourni pour les programmeurs plus familiers avec GCC ou Clang.

Notez que même si l'espace entre /o et le dossier et / ou le nom spécifié est facultatif, il ne doit pas y avoir d'espace entre /Fe et le dossier et / ou le nom spécifiés.

De même, pour produire un exécutable optimisé (à utiliser en production), utilisez:

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.

Enfin, pour créer un exécutable optimisé spécifique à la plate-forme (à utiliser en production sur la machine avec l'architecture spécifiée), choisissez l'invite de commande ou le paramètre VCVARSALL pour la plate-forme cible. link devrait détecter la plate-forme souhaitée à partir des fichiers objets; Sinon, utilisez l' option /MACHINE pour spécifier explicitement la plate-forme cible.

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

Tout ce qui précède produira un exécutable avec le nom spécifié par /o ou /Fe , ou si aucun n'est fourni, avec un nom identique au premier fichier source ou objet spécifié pour le compilateur.

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

Pour compiler un fichier sans liaison, utilisez:

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

Cela indique à cl de quitter sans appeler le link et produit un fichier objet, qui peut ensuite être lié à d'autres fichiers pour produire un fichier binaire.

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

Il existe également d'autres paramètres de ligne de commande précieux, qu'il serait très utile de connaître pour les utilisateurs:

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

Pour ceux qui connaissent mieux les systèmes * nix et / ou GCC / Clang, les outils de ligne de commande cl , link et autres Visual Studio peuvent accepter les paramètres spécifiés avec un trait d'union (tel que -c ) au lieu d'une barre oblique (tel que /c ). En outre, Windows reconnaît une barre oblique ou une barre oblique inverse comme séparateur de chemin d'accès valide. Par conséquent, les chemins d'accès de style * nix peuvent également être utilisés. Cela facilite la conversion de lignes de commande simples du compilateur de g++ ou clang++ en cl , ou vice versa, avec des modifications minimales.

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

Bien entendu, lorsque vous portez des lignes de commande utilisant des options g++ ou clang++ plus complexes, vous devez rechercher des commandes équivalentes dans les documentations de compilateurs et / ou sur les sites de ressources, mais cela facilite le démarrage nouveaux compilateurs.

Si vous avez besoin de fonctionnalités linguistiques spécifiques pour votre code, une version spécifique de MSVC était requise. À partir de Visual C ++ 2015 Update 3 , il est possible de choisir la version du standard à compiler via l'indicateur /std . Les valeurs possibles sont /std:c++14 et /std:c++latest ( /std:c++17 suivra bientôt).

Remarque: Dans les anciennes versions de ce compilateur, des indicateurs de fonctionnalités spécifiques étaient disponibles, mais cette option était principalement utilisée pour les aperçus de nouvelles fonctionnalités.

Compiler avec Visual Studio (interface graphique) - Hello World

1. Téléchargez et installez Visual Studio Community 2015
2. Open Visual Studio Community
3. Cliquez sur Fichier -> Nouveau -> Projet
4. Cliquez sur Modèles -> Visual C ++ -> Application Console Win32, puis nommez le projet MyFirstProgram .
5. Cliquez sur OK
6. Cliquez sur Suivant dans la fenêtre suivante.
7. Cochez la case Empty project , puis cliquez sur Terminer:
8. Faites un clic droit sur le dossier Fichier source puis -> Ajouter -> Nouvel élément:
9. Sélectionnez Fichier C ++ et nommez le fichier main.cpp, puis cliquez sur Ajouter: 10: Copiez et collez le code suivant dans le nouveau fichier main.cpp:

#include <iostream>

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

Votre environnement devrait ressembler à:

11. Cliquez sur Debug -> Start Without Debugging (ou appuyez sur Ctrl + F5):

12. Terminé. Vous devriez obtenir la sortie de console suivante:

Compiler avec Clang

Le frontal de Clang étant conçu pour être compatible avec GCC, la plupart des programmes pouvant être compilés via GCC seront compilés lorsque vous clang++ g++ par clang++ dans les scripts de construction. Si aucune -std=version n'est donnée, gnu11 sera utilisé.

Les utilisateurs Windows habitués à MSVC peuvent échanger cl.exe avec clang-cl.exe . Par défaut, clang essaie d'être compatible avec la version la plus élevée de MSVC installée.

Dans le cas d'une compilation avec Visual Studio, clang-cl peut être utilisé en modifiant le Platform toolset dans les propriétés du projet.

Dans les deux cas, clang est uniquement compatible via son front-end, bien qu'il tente également de générer des fichiers d'objets compatibles binaires. Les utilisateurs de clang-cl doivent noter que la compatibilité avec MSVC n'est pas encore complète .

Pour utiliser clang ou clang-cl, on pourrait utiliser l'installation par défaut sur certaines distributions Linux ou celles fournies avec des IDE (comme XCode sur Mac). Pour les autres versions de ce compilateur ou sur les plates-formes sur lesquelles ce n'est pas installé, vous pouvez le télécharger depuis la page de téléchargement officielle .

Si vous utilisez CMake pour créer votre code, vous pouvez généralement changer le compilateur en définissant les variables d'environnement CC et CXX comme ceci:

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

Voir aussi introduction à Cmake .

Compilateurs en ligne

Divers sites Web offrent un accès en ligne aux compilateurs C ++. Les fonctionnalités du compilateur en ligne varient considérablement d'un site à l'autre, mais elles permettent généralement d'effectuer les opérations suivantes:

• Collez votre code dans un formulaire Web dans le navigateur.
• Sélectionnez des options de compilation et compilez le code.
• Collecte les sorties du compilateur et / ou du programme.

Le comportement du site Web du compilateur en ligne est généralement assez restrictif car il permet à quiconque d'exécuter des compilateurs et d'exécuter du code arbitraire côté serveur, alors que l'exécution de code arbitraire à distance est généralement considérée comme une vulnérabilité.

Les compilateurs en ligne peuvent être utiles aux fins suivantes:

• Exécutez un petit extrait de code à partir d'une machine dépourvue du compilateur C ++ (smartphones, tablettes, etc.).
• Assurez-vous que le code compile correctement avec différents compilateurs et s'exécute de la même manière quel que soit le compilateur avec lequel il a été compilé.
• Apprendre ou enseigner les bases du C ++.
• Découvrez les fonctionnalités C ++ modernes (C ++ 14 et C ++ 17 dans un futur proche) lorsque le compilateur C ++ à jour n'est pas disponible sur la machine locale.
• Repérez un bogue dans votre compilateur en le comparant à un grand nombre d’autres compilateurs. Vérifiez si un bogue du compilateur a été corrigé dans les futures versions, qui ne sont pas disponibles sur votre ordinateur.
• Résoudre des problèmes de juge en ligne.

Quels compilateurs en ligne ne devraient pas être utilisés pour:

• Développez des applications complètes (même petites) en utilisant C ++. Généralement, les compilateurs en ligne ne permettent pas de créer des liens avec des bibliothèques tierces ou de télécharger des artefacts de génération.
• Effectuer des calculs intensifs. Les ressources informatiques côté serveur étant limitées, tout programme fourni par l'utilisateur sera tué après quelques secondes d'exécution. Le temps d'exécution autorisé est généralement suffisant pour les tests et l'apprentissage.
• Attaquez le serveur de compilateur lui-même ou tout hôte tiers sur le net.

Exemples:

Déni de responsabilité: les auteurs de la documentation ne sont affiliés à aucune des ressources énumérées ci-dessous. Les sites Web sont classés par ordre alphabétique.

• http://codepad.org/ Compilateur en ligne avec partage de code. La modification du code après la compilation avec un avertissement ou une erreur de code source ne fonctionne pas si bien.
• http://coliru.stacked-crooked.com/ Compilateur en ligne pour lequel vous spécifiez la ligne de commande. Fournit des compilateurs GCC et Clang à utiliser.
• http://cpp.sh/ - Compilateur en ligne avec support C ++ 14. Ne vous permet pas d'éditer la ligne de commande du compilateur, mais certaines options sont disponibles via les contrôles de l'interface graphique.
• https://gcc.godbolt.org/ - Fournit une liste étendue des versions du compilateur, des architectures et des résultats de désassemblage. Très utile lorsque vous devez inspecter ce que votre code compile en différents compilateurs. GCC, Clang, MSVC ( CL ), le compilateur Intel ( icc ), ELLCC et Zapcc sont présents, avec un ou plusieurs de ces compilateurs disponibles pour l'ARM, ARMv8 (comme ARM64), Atmel AVR, MIPS, MIPS64, MSP430, PowerPC. , architectures x86 et x64. Les arguments de la ligne de commande du compilateur peuvent être modifiés.
• https://ideone.com/ - Largement utilisé sur le Net pour illustrer le comportement des extraits de code. Fournit GCC et Clang pour une utilisation, mais ne vous permet pas de modifier la ligne de commande du compilateur.
• http://melpon.org/wandbox - Prend en charge de nombreuses versions du compilateur Clang et GNU / GCC.
• http://onlinegdb.com/ - Un IDE extrêmement minimaliste qui inclut un éditeur, un compilateur (gcc) et un débogueur (gdb).
• http://rextester.com/ - Fournit des compilateurs Clang, GCC et Visual Studio pour C et C ++ (ainsi que des compilateurs pour d'autres langages), avec la bibliothèque Boost disponible pour utilisation.
• http://tutorialspoint.com/compile_cpp11_online.php - Un shell UNIX complet avec GCC et un explorateur de projet convivial.
• http://webcompiler.cloudapp.net/ - Compilateur en ligne Visual Studio 2015, fourni par Microsoft dans le cadre de RiSE4fun.

Le processus de compilation C ++

Lorsque vous développez un programme C ++, l'étape suivante consiste à compiler le programme avant de l'exécuter. La compilation est le processus qui convertit le programme écrit dans un langage lisible par l'homme, comme C, C ++, etc., en un code machine, directement compris par l'unité centrale de traitement. Par exemple, si vous avez un fichier de code source C ++ nommé prog.cpp et que vous exécutez la commande de compilation,

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

La création d'un fichier exécutable à partir du fichier source comporte quatre étapes principales.

1. Le préprocesseur C ++ utilise un fichier de code source C ++ et gère les en-têtes (#include), les macros (#define) et les autres directives de préprocesseur.

2. Le fichier de code source C ++ développé par le préprocesseur C ++ est compilé dans le langage d'assemblage de la plateforme.

3. Le code assembleur généré par le compilateur est assemblé dans le code objet de la plate-forme.

4. Le fichier de code objet produit par l'assembleur est lié entre eux
   avec les fichiers de code objet pour toutes les fonctions de bibliothèque utilisées pour produire une bibliothèque ou un fichier exécutable.

Prétraitement

Le préprocesseur gère les directives de préprocesseur, telles que #include et #define. Il est agnostique de la syntaxe de C ++, c'est pourquoi il doit être utilisé avec précaution.

Il fonctionne sur un fichier source C ++ à la fois en remplaçant les directives #include par le contenu des fichiers respectifs (qui ne sont généralement que des déclarations), en remplaçant les macros (#define) et en sélectionnant différentes parties du texte en fonction de #if, Directives #ifdef et #ifndef.

Le préprocesseur fonctionne sur un flux de jetons de prétraitement. La substitution de macros est définie comme le remplacement de jetons par d'autres jetons (l'opérateur ## permet de fusionner deux jetons lorsque cela se justifie).

Après tout cela, le préprocesseur produit une seule sortie qui est un flux de jetons résultant des transformations décrites ci-dessus. Il ajoute également des marqueurs spéciaux indiquant au compilateur d'où provient chaque ligne, afin de pouvoir les utiliser pour générer des messages d'erreur sensibles.

Certaines erreurs peuvent être produites à ce stade avec une utilisation intelligente des directives #if et #error.

En utilisant l'indicateur de compilation ci-dessous, nous pouvons arrêter le processus à l'étape de prétraitement.

g++ -E prog.cpp

Compilation

L'étape de compilation est effectuée sur chaque sortie du préprocesseur. Le compilateur analyse le code source C ++ pur (maintenant sans directives du préprocesseur) et le convertit en code assembleur. Invoque ensuite le back-end sous-jacent (assembleur dans toolchain) qui assemble ce code en code machine produisant un fichier binaire réel dans un certain format (ELF, COFF, a.out, ...). Ce fichier objet contient le code compilé (sous forme binaire) des symboles définis dans l'entrée. Les symboles dans les fichiers objets sont désignés par leur nom.

Les fichiers d'objets peuvent faire référence à des symboles non définis. C'est le cas lorsque vous utilisez une déclaration et ne la définissez pas. Cela ne dérange pas le compilateur et produira avec plaisir le fichier objet tant que le code source est bien formé.

Les compilateurs vous laissent généralement arrêter la compilation à ce stade. Ceci est très utile car vous pouvez compiler chaque fichier de code source séparément. L'avantage que cela procure est que vous n'avez pas besoin de tout recompiler si vous ne modifiez qu'un seul fichier.

Les fichiers d'objet produits peuvent être placés dans des archives spéciales appelées bibliothèques statiques, pour une réutilisation plus facile par la suite.

C'est à ce stade que sont signalées les erreurs "régulières" du compilateur, telles que les erreurs de syntaxe ou les erreurs de résolution des surcharges.

Afin d'arrêter le processus après l'étape de compilation, nous pouvons utiliser l'option -S:

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

Assemblage

L'assembleur crée le code objet. Sur un système UNIX, vous pouvez voir des fichiers avec un suffixe .o (.OBJ sur MSDOS) pour indiquer les fichiers de code objet. Au cours de cette phase, l'assembleur convertit ces fichiers objets du code assembleur en instructions de niveau machine et le fichier créé est un code objet relogeable. Par conséquent, la phase de compilation génère le programme objet relogeable et ce programme peut être utilisé à différents endroits sans avoir à compiler à nouveau.

Pour arrêter le processus après l'étape d'assemblage, vous pouvez utiliser l'option -c:

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

Mise en relation

L'éditeur de liens est ce qui produit la sortie finale de la compilation à partir des fichiers objets produits par l'assembleur. Cette sortie peut être soit une bibliothèque partagée (ou dynamique) (et même si le nom est similaire, ils n’ont pas beaucoup de points communs avec les bibliothèques statiques mentionnées précédemment) ou un exécutable.

Il lie tous les fichiers objets en remplaçant les références à des symboles non définis par les adresses correctes. Chacun de ces symboles peut être défini dans d'autres fichiers objets ou dans des bibliothèques. S'ils sont définis dans des bibliothèques autres que la bibliothèque standard, vous devez en informer l'éditeur de liens.

À ce stade, les erreurs les plus courantes sont les définitions manquantes ou les définitions en double. Le premier signifie que les définitions n'existent pas (c'est-à-dire qu'elles ne sont pas écrites), ou que les fichiers d'objets ou les bibliothèques où ils résident ne sont pas fournis à l'éditeur de liens. Ce dernier est évident: le même symbole a été défini dans deux fichiers ou bibliothèques d'objets différents.

Compiler avec Code :: Blocks (interface graphique)

1. Téléchargez et installez Code :: Blocks ici . Si vous êtes sous Windows, veillez à sélectionner un fichier pour lequel le nom contient mingw , les autres fichiers n’installent aucun compilateur.

2. Ouvrez Code :: Blocks et cliquez sur "Créer un nouveau projet":

   

3. Sélectionnez "Application console" et cliquez sur "Go":

   

4. Cliquez sur "Suivant", sélectionnez "C ++", cliquez sur "Suivant", sélectionnez un nom pour votre projet et choisissez un dossier pour l'enregistrer, cliquez sur "Suivant" puis cliquez sur "Terminer".

5. Maintenant, vous pouvez éditer et compiler votre code. Un code par défaut qui affiche "Hello world!" dans la console est déjà là. Pour compiler et / ou exécuter votre programme, appuyez sur l’un des trois boutons de compilation / exécution de la barre d’outils:

   

   Pour compiler sans exécuter, appuyez sur , pour exécuter à nouveau sans compilation, appuyez sur et pour compiler puis exécuter, appuyez sur .

   Compiler et exécuter la valeur par défaut "Hello world!" le code donne le résultat suivant: