Comment compiler C++ en utilisant g++ sous Linux

Cet article partage principalement avec vous la méthode de compilation de C++ avec g++ dans l'environnement Linux et le partage d'exemples de codes associés. Les amis intéressés peuvent en tirer des leçons. J'espère que cela aide tout le monde.

Un fichier source unique génère un programme exécutable

Ce qui suit est le code d'un simple programme C++ enregistré dans le fichier helloworld.cpp :

/* helloworld.cpp */
#include <iostream>
int main(int argc,char *argv[])
{
  std::cout << "hello, world" << std::endl;
  return(0);
}

Le programme utilise cout défini dans le fichier d'en-tête iostream pour écrire une chaîne simple sur la sortie standard. Ce code peut être compilé dans un fichier exécutable avec la commande suivante :

$ g++ helloworld.cpp

Le compilateur g++ peut l'identifier comme code source C++ en vérifiant le nom suffixe du fichier spécifié sur le document de ligne de commande. L'action par défaut du compilateur : compiler le fichier de code source pour générer un fichier objet (fichier objet), lier le fichier objet et les fonctions dans la bibliothèque libstdc++ pour obtenir un programme exécutable. Supprimez ensuite le fichier objet. Étant donné que le nom de fichier du programme exécutable n'est pas spécifié sur la ligne de commande, le compilateur utilise le fichier a.out par défaut. Le programme peut être exécuté comme ceci :

$ ./a.out
hello, world

Une approche plus courante consiste à spécifier le nom de fichier du programme exécutable via l'option -o. La commande suivante produira un fichier exécutable nommé helloworld :

$ g++ helloworld.cpp -o helloworld

Entrez le nom du programme sur la ligne de commande pour l'exécuter :

$ ./helloworld
hello, world

Le programme g++ est une version spéciale qui définit le langage par défaut de gcc sur C++. Il utilise automatiquement la bibliothèque standard C++ au lieu de la bibliothèque standard C lors de la liaison. En suivant la convention de dénomination du code source et en spécifiant le nom de la bibliothèque correspondante, il est possible d'utiliser gcc pour compiler et lier des programmes C++, comme le montre l'exemple suivant :

$ gcc helloworld.cpp -lstdc++ -o helloworld

option -l (ell) Convertissez le nom qui le suit en nom de la bibliothèque libstdc++.a en ajoutant le préfixe lib et le suffixe .a. Ensuite, il recherche la bibliothèque dans le chemin de bibliothèque standard. Le processus de compilation et les fichiers de sortie de gcc sont exactement les mêmes que ceux de g++.

Sur la plupart des systèmes, GCC installe un programme appelé c++. S'il est installé, il équivaut à g++, comme le montre l'exemple suivant, et son utilisation est cohérente :

$ c++ helloworld.cpp -o helloworld

Plusieurs fichiers sources génèrent des programmes exécutables

Si plusieurs fichiers de code source sont spécifiés dans la commande g++, ils seront tous compilés et liés en un seul fichier exécutable. Vous trouverez ci-dessous un fichier d'en-tête appelé speak.h ; il contient la définition d'une classe qui ne contient qu'une seule fonction :

/* speak.h */
#include <iostream>
class Speak
{
  public:
    void sayHello(const char *);
};

Vous trouverez ci-dessous le contenu du fichier speak. cpp : Le corps de la fonction contenant la fonction sayHello() :

/* speak.cpp */
#include "speak.h"
void Speak::sayHello(const char *str)
{
  std::cout << "Hello " << str << "\n";
}

Le fichier hellospeak.cpp est un programme utilisant la classe Speak :

/* hellospeak.cpp */
#include "speak.h"
int main(int argc,char *argv[])
{
  Speak speak;
  speak.sayHello("world");
  return(0);
}

La commande suivante compile et lie les deux fichiers de code source ci-dessus en un seul programme exécutable :

$ g++ hellospeak.cpp speak.cpp -o hellospeak

PS : Allons expliquer pourquoi le fichier "speak.h" n'est pas mentionné dans la commande (la raison est la suivante : "#include"speak.h"" est inclus dans "speak.cpp", ce qui signifie rechercher. Le répertoire des fichiers d'en-tête du système recherchera d'abord pour le fichier "speak.h" dans le répertoire courant et "speak.h" est dans ce répertoire et n'a pas besoin d'être spécifié dans la commande).

Le fichier source génère un fichier objet

L'option -c est utilisée pour indiquer au compilateur de compiler le code source mais de ne pas effectuer de liaison, et la sortie le résultat est un fichier objet. Le nom de fichier par défaut est le même que le nom du fichier source, sauf que le suffixe est remplacé par .o. Par exemple, la commande suivante compilera le fichier de code source hellospeak.cpp et générera le fichier objet hellospeak.o :

$ g++ -c hellospeak.cpp

La commande g++ peut également reconnaître .o fichiers et les traiter comme des fichiers d'entrée sont transmis à l'éditeur de liens. La commande suivante compilera les fichiers source en fichiers objets et les reliera en un seul programme exécutable :

$ g++ -c hellospeak.cpp 
$ g++ -c speak.cpp 
$ g++ hellospeak.o speak.o -o hellospeak

L'option -o peut être utilisée pour nommer plus que simplement un exécutable. fichiers . Il est également utilisé pour nommer d'autres fichiers générés par le compilateur. Par exemple : sauf que les fichiers objets intermédiaires ont des noms différents, la commande suivante générera exactement le même fichier exécutable que ci-dessus :

$ g++ -c hellospeak.cpp -o hspk1.o 
$ g++ -c speak.cpp -o hspk2.o 
$ g++ hspk1.o hspk2.o -o hellospeak

Compile pré-traitement

option -E oblige g++ à traiter le code source avec le préprocesseur de compilation et à n'effectuer plus d'autres actions. La commande suivante prétraite le fichier de code source helloworld.cpp et affiche les résultats dans la sortie standard :

$ g++ -E helloworld.cpp

Le code source de helloworld.cpp répertorié plus haut dans cet article , Il n'y a que six lignes et le programme ne fait rien d'autre qu'afficher une ligne de texte, mais la version prétraitée comportera plus de 1 200 lignes. Cela est principalement dû au fait que le fichier d'en-tête iostream est inclus et qu'il contient d'autres fichiers d'en-tête. De plus, il existe des définitions de plusieurs classes qui gèrent les entrées et les sorties.

Le suffixe GCC du fichier prétraité est .ii, qui peut être généré avec l'option -o, par exemple :

$ gcc -E helloworld.cpp -o helloworld.ii

Générer du code assembleur

L'option -S demande au compilateur de compiler le programme en langage assembleur, de générer le code en langage assembleur, puis de terminer. La commande suivante générera le fichier de langage assembleur helloworld.s à partir du fichier de code source C++ :

$ g++ -S helloworld.cpp

生成的汇编语言依赖于编译器的目标平台。

创建静态库

静态库是编译器生成的一系列对象文件的集合。链接一个程序时用库中的对象文件还是目录中的对象文件都是一样的。库中的成员包括普通函数，类定义，类的对象实例等等。静态库的另一个名字叫归档文件(archive)，管理这种归档文件的工具叫 ar 。

在下面的例子中，我们先创建两个对象模块，然后用其生成静态库。

头文件 say.h 包含函数 sayHello() 的原型和类 Say 的定义：

/* say.h */
#include <iostream>
void sayhello(void);
class Say {
  private:
    char *string;
  public:
    Say(char *str)
    {
      string = str;
    }
    void sayThis(const char *str)
    {
      std::cout << str << " from a static library\n";
    }
    void sayString(void);
};

下面是文件 say.cpp 是我们要加入到静态库中的两个对象文件之一的源码。它包含 Say 类中 sayString() 函数的定义体；类 Say 的一个实例 librarysay 的声明也包含在内：

/* say.cpp */
#include "say.h"
void Say::sayString()
{
  std::cout << string << "\n";
}
 
Say librarysay("Library instance of Say");

源码文件 sayhello.cpp 是我们要加入到静态库中的第二个对象文件的源码。它包含函数 sayhello() 的定义：

/* sayhello.cpp */
#include "say.h"
void sayhello()
{
  std::cout << "hello from a static library\n";
}

下面的命令序列将源码文件编译成对象文件，命令 ar 将其存进库中：

$ g++ -c sayhello.cpp
$ g++ -c say.cpp
$ ar -r libsay.a sayhello.o say.o

程序 ar 配合参数 -r 创建一个新库 libsay.a 并将命令行中列出的对象文件插入。采用这种方法，如果库不存在的话，参数 -r 将创建一个新的库，而如果库存在的话，将用新的模块替换原来的模块。

下面是主程序 saymain.cpp，它调用库 libsay.a 中的代码：

/* saymain.cpp */
#include "say.h"
int main(int argc,char *argv[])
{
  extern Say librarysay;
  Say localsay = Say("Local instance of Say");
  sayhello();
  librarysay.sayThis("howdy");
  librarysay.sayString();
  localsay.sayString();
  return(0);
}

该程序可以下面的命令来编译和链接：

$ g++ saymain.cpp libsay.a -o saymain

程序运行时，产生以下输出：

hello from a static library
howdy from a static library
Library instance of Say
Local instance of Say

ps：如果一个文件夹下有多个cpp文件需要编译的话，除了采用makefile的方式之外，还可以使用“g++ *.cpp -o hello",“hello为编译生成的可执行文件的名字”，编译时要确保cpp文件和他们各自所引用的头文件在同一个目录下。

相关推荐：

在Linux环境下g++编译GDAL动态库的操作方法

Linux下g++编译以及使用静态库和动态库的方法详解

Linux下如何实现C++操作Mysql数据库的详细介绍

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!