Une foule de bibliothèques

La réponse à cette question dépend de ce que vous cherchez. C++ étant un langage populaire, vous trouverez des bibliothèques externes dans de nombreux domaines, comme les graphismes 2D, la communication réseau, la manipulation de sons, des outils mathématiques supplémentaires, etc. Ceci étant dit, nous sommes dans un cours d’introduction, donc je me dois de choisir pour vous. Dans ce chapitre, nous apprendrons donc à installer et utiliser brièvement deux bibliothèques externes, respectivement nommées Boost et SFML.

Vous aurez ainsi vu plusieurs manières d’installer une bibliothèque externe, donc vous ne serez pas perdus lorsque vous en aurez besoin.

Boost

La première que nous verrons, Boost, c’est un peu comme l’extension officieuse de la bibliothèque standard C++. Au fil des années, de nombreuses fonctionnalités implémentées dans Boost se sont retrouvées intégrées à la bibliothèque standard C++. Citons par exemple std::array, std::tuple ou encore de nombreuses fonctions mathématiques.

L’installer, c’est s’offrir les services d’une bibliothèque de grande qualité, répandue, conçue par des développeurs experts, donc vous avez tout à gagner à apprendre à l’utiliser. Elle propose, entre autres, des tests unitaires, mais également un moyen d’interfacer son code avec Python, travailler avec des quaternions et bien d’autres choses encore.

SFML

L’autre que j’aimerai que vous découvriez est une bibliothèque 2D très connue et utilisée en C++, SFML. Elle vous permet de gérer tout ce qui touche aux jeux 2D, comme le son, les graphismes et le réseau. Et ne vous inquiétez pas, elle est portable et fonctionne sur de nombreuses plateformes, dont Windows et GNU/Linux.

En plus, la documentation est en français. C’est pas beau la vie ?

La plupart des bibliothèques externes fonctionnent sur le même principe que la bibliothèque standard, c’est-à-dire qu’on a des fichiers d’en-têtes et des fichiers objets, entre autres. Les premiers sont nécessaires pour la compilation, les seconds pour le linker, comme nous l’avons vu dans le chapitre sur la compilation. Mais ce n’est pas tout. Souvent sont joints des exemples, ainsi qu’une version hors-ligne de la documentation.

Statique ou dynamique ?

Les fichiers objets d’une bibliothèque externe peuvent être joints au programme de deux manières différentes.

• Avec une bibliothèque statique, les fichiers objets sont directement liés au programme. Celui-ci devient plus gros, mais est désormais utilisable tel quel, sans fichier supplémentaire à joindre avec l’exécutable.
• Avec une bibliothèque dynamique, les fichiers objets sont chargés à l’exécution du programme. L’avantage, c’est qu’une même copie de la bibliothèque peut être utilisée par de nombreux programmes. L’inconvénient, c’est qu’il faut fournir ces fichiers avec l’exécutable du programme. Sous Windows, ce sont les fameux fichiers .dll.

La très grande majorité des bibliothèques externes sont utilisables de façon statique ou dynamique, au choix.

Debug ou release ?

De la même manière que nos programmes, les bibliothèques externes sont compilées tant en debug qu’en release. Cela permet d’offrir une expérience de débogage et des tests pendant qu’on développe notre programme, avec les symboles de débogage présents et une expérience optimisée et plus rapide une fois qu’on passe en release.

Commençons donc par Boost. Cette bibliothèque est composée majoritairement de fichiers d’en-tête, qu’on peut inclure simplement, sans plus d’histoire. Cependant, quelques parties demandent d’être compilées. Nous allons donc voir comment installer la version complète de Boost sur chaque plateforme.

GNU/Linux

Vous êtes dans le cas le plus facile, puisqu’il y a de grandes chances que votre distribution préférée fournisse des paquets prêts à l’emploi. Par exemple, pour Ubuntu, c’est la commande suivante qui installe le tout.

sudo apt-get install libboost-all-dev

Renseignez-vous dans la documentation de votre distribution pour le nom exact du paquet.

Windows

Les utilisateurs de Windows sont moins chanceux. De base, il faudrait compiler nous-mêmes une version de Boost. Pour ceux utilisant Visual Studio, une solution simple existe. Pour ceux utilisant Qt Creator…

Visual Studio

Commencez par vous rendre ici. Sur la page des versions, prenez la dernière disponible (1.69 à l’heure où j’écris), puis téléchargez boost_1_69_0-msvc-14.1–32.exe, ainsi que boost_1_69_0-msvc-14.1–64.exe si vous avez un système d’exploitation 64 bits. Une fois l’exécutable téléchargé, installez-le dans le dossier de votre choix. Si vous prenez les deux, installez les deux dans le même dossier. Ne vous en faites pas, il n’y a pas de risque d’écrasement.

Maintenant, ouvrez un projet quelconque et rendez-vous dans ses propriétés, avec un clic-droit sur le nom du projet. Il va en effet falloir indiquer au compilateur où se trouvent les fichiers de Boost. Commençons par nous mettre en configuration générale, en mettant le champ Configuration à Toutes les configurations et Plateforme à Toutes les plateformes.

Incluons le dossier contenant tous les fichiers d’en-tête en allant dans C/C++ -> Général, puis en faisant modifier sur le champ Autres répertoires Include. Dans le cadre du haut, mettez le chemin du dossier dans lequel vous avez installé Boost. Chez moi, le chemin complet est C:\Programmation\Boost.1.69.

Maintenant, allons dans Éditeur de liens -> Général et modifions le champ Répertoires de bibliothèques supplémentaires pour rajouter le dossier contenant les fichiers objets. Dans le cas où vous n’avez que la version 32 bits, modifiez-le et ajoutez le chemin où vous avez installé Boost plus lib32-msvc-14.1. Chez moi, le chemin complet est C:\Programmation\Boost.1.69\lib32-msvc-14.1.

Dans le cas où vous avez les deux versions, 32 bits et 64 bits, il va falloir adapter le chemin donné. Tout d’abord, modifiez le champ Plateforme en haut pour le mettre à Win32. Puis, dans Éditeur de liens -> Général, modifiez le champ Répertoires de bibliothèques supplémentaires. Ajoutez-y le chemin où vous avez installé Boost plus lib32-msvc-14.1. Une fois fait, cliquez sur Appliquer puis retourner modifier le champ Plateforme en le mettant cette fois à x64. Faîtes la même chose que précédemment mais en sélectionnant cette fois le dossier lib64-msvc-14.1

• Pour Win32, j’ai dans mon cas le chemin C:\Programmation\Boost.1.69\lib32-msvc-14.1.
• Pour x64, j’ai dans mon cas le chemin C:\Programmation\Boost.1.69\lib64-msvc-14.1.

Validez et tout est bon.

Qt Creator

Quant à ceux utilisant Qt Creator, ils gagnent le droit de compiler eux-mêmes Boost. Ne vous inquiétez pas, ce n’est pas si compliqué qu’il n’y parait et je vais tout vous expliquer. Il faut commencer par télécharger la dernière version disponible (1.69 à l’heure où j’écris) et la décompressez dans le dossier de votre choix.

Maintenant, on va lancer l’invite de commande installé en même temps que Qt Creator. Dans mon cas, je le trouve dans Menu démarrer -> Qt -> 5.12.2 -> MinGW 7.3.0 (32 bits) -> Qt 5.12.2 (MinGW 7.3.0 32-bit) (les numéros de version peuvent changer). Il va nous servir à compiler Boost.

Rendez-vous dans le dossier où vous avez décompressé Boost à l’aide de la console. Dans mon cas, c’est C:\Users\informaticienzero\Downloads\boost_1_69_0. La commande pour changer de dossier est cd.

cd C:\Users\informaticienzero\Downloads\boost_1_69_0

Une fois dedans, on va préparer l’installation en exécutant la commande suivante. Entre guillemets après --prefix, mettez le chemin de sortie où les bibliothèques composant Boost seront stockées. Pour moi, j’ai pris C:\Programmation\Boost.

bootstrap gcc --prefix="C:\Programmation\Boost"

Maintenant, il est temps de lancer la compilation pour de bon. Voici la ligne à taper. Oui, elle est très longue.

b2 install address-model=32 --build-type=complete architecture=x86 threading=multi --build-dir="C:\Programmation\Boost" toolset=gcc debug release link=static runtime-link=static cxxflags="-std=c++17"

• L’option address-model=32 indique qu’on veut compiler une version 32 bits de la bibliothèque.
• L’option architecture=x86 indique qu’on compile pour un PC, qui utilisent quasiment tous cette architecture.
• L’option --build-dir="C:\Programmation\Boost" indique où on veut stocker les fichiers objets générés.
• Les options debug release indique qu’on veut disposer tant de la version debug que release.
• L’option link=static indique qu’on veut compiler une version statique uniquement, ce qui est fortement recommandé sous Windows.
• L’option cxxflags="-std=c++17" indique qu’on veut compiler avec C++17.

La compilation peut être assez longue donc lancez-la et faites autre chose en attendant. Une fois qu’elle a fini, il faut configurer Qt Creator. Cela se passe dans le fichier .pro. On commence par indiquer où trouver les fichiers d’en-tête.

# Adaptez en fonction du chemin d'installation.
INCLUDEPATH += C:/Boost/include/boost-1_69

Maintenant, on va ajouter le dossier contenant les fichiers objets.

# Adaptez en fonction du chemin d'installation.
LIBS += -L"C:/Boost/lib"

Voilà, l’installation est terminée, il ne restera plus qu’à ajouter individuellement les bibliothèques requises dans le fichier .pro.

Tester l’installation

Prenons par exemple le code d’illustration de Boost.Log, un système d’écriture de messages de journalisation. Je le remets ci-dessous.

#include <boost/log/trivial.hpp>

int main()
{
    BOOST_LOG_TRIVIAL(trace) << "A trace severity message";
    BOOST_LOG_TRIVIAL(debug) << "A debug severity message";
    BOOST_LOG_TRIVIAL(info) << "An informational severity message";
    BOOST_LOG_TRIVIAL(warning) << "A warning severity message";
    BOOST_LOG_TRIVIAL(error) << "An error severity message";
    BOOST_LOG_TRIVIAL(fatal) << "A fatal severity message";

    return 0;
}

Pour compiler en ligne de commande, il faut rajouter quelques options, dues à des dépendances du système de logging fourni par Boost.

• L’option -static indique au compilateur qu’on veut lier statiquement Boost.Log à notre programme.
• Les options -lboost_log et -lboost_log_setup permettent de lier les deux bibliothèques nécessaires à Boost.Log.
• Les options -lboost_thread, -lboost_system et -lpthread lient d’autres dépendances de Boost.Log à notre programme. On trouve notamment Boost.Thread et Boost.System, deux autres bibliothèques inclues par Boost, ainsi qu’une dépendance à une bibliothèque commune à toutes les distributions GNU/Linux et UNIX.

g++ -std=c++17 -static main.cpp -o main.out -lboost_log -lboost_log_setup -lboost_thread -lboost_system -lpthread

Pour ceux utilisant Qt Creator, on doit ajouter les lignes suivantes dans le fichier .pro. Ce sont les bibliothèques nécessaires pour compiler le code d’exemple de Boost.Log. On retrouve log et log_setup, ainsi que la bibliothèque thread. Notez qu’on fait la différence entre les versions debug (avec d) et release (sans d).

CONFIG(debug, debug|release) {
    # Bibliothèques en debug.
    LIBS += -lboost_log-mgw73-mt-sd-x64-1_69
    LIBS += -lboost_log_setup-mgw73-mt-sd-x64-1_69
    LIBS += -lboost_thread-mgw73-mt-sd-x64-1_69
}

CONFIG(release, debug|release) {
    # Bibliothèques en release.
    LIBS += -lboost_log-mgw73-mt-s-x64-1_69
    LIBS += -lboost_log_setup-mgw73-mt-s-x64-1_69
    LIBS += -lboost_thread-mgw73-mt-s-x64-1_69
}

Dans tous les cas, une fois compilé et lancé, le programme affichera la sortie suivante, avec seulement l’heure changeant en fonction du moment où vous lancerez le programme.

[2019-03-23 19:13:42.109558] [0x00004e2c] [trace]   A trace severity message
[2019-03-23 19:13:42.111576] [0x00004e2c] [debug]   A debug severity message
[2019-03-23 19:13:42.111576] [0x00004e2c] [info]    An informational severity message
[2019-03-23 19:13:42.112561] [0x00004e2c] [warning] A warning severity message
[2019-03-23 19:13:42.112561] [0x00004e2c] [error]   An error severity message
[2019-03-23 19:13:42.112561] [0x00004e2c] [fatal]   A fatal severity message

Maintenant, abordons l’installation de la deuxième bibliothèque, la SFML. Encore une fois, nous allons détailler par environnement.

GNU/Linux

Vous êtes encore des chanceux, puisque la plupart des distributions proposent des paquets permettant d’avoir une SFML à jour en une commande. Ainsi, avec Ubuntu, il suffit de taper la commande qui suit.

sudo apt-get install libsfml-dev

Renseignez-vous pour le nom exact du paquet pour votre distribution.

Windows

Pour Windows, il va falloir installer manuellement. Pas de soucis, la documentation est très bien faite, en français et vous bénéficiez de nos explications en prime. Commençons par nous rendre sur la page de téléchargement. À l’heure où j’écris, elle propose la version 2.5.1 de SFML.

Plusieurs versions sont disponibles au téléchargement, en fonction du compilateur que vous utilisez. Dans notre cas, il s’agira de prendre soit la version Visual C++ 15 (2017) pour ceux ayant installé Visual Studio 2017, soit la version GCC 7.3.0 MinGW pour ceux utilisant Qt Creator. Dans les deux cas, prenez la version 32 bits. Même si la très grande majorité des processeurs vendus aujourd’hui sont 64 bits, avec la version 32 bits vous pourrez cibler les deux-plateformes. Si vous prenez la version 64 bits, vous ne pourrez cibler que les ordinateurs ayant un processeur et un système d’exploitation 64 bits.

Dans tous les cas, vous obtenez une archive que vous pouvez décompresser dans le dossier de votre choix. Certains vont le mettre dans un dossier bien à part, comme C:/Programmation/SFML, d’autres préfèrent le mettre dans le dossier de leur projet, ce qui permet de distribuer les sources et de changer d’ordinateur en un simple copier-coller, car la configuration est enregistrée avec le projet. Ce choix est vôtre.

Avec Visual Studio

Voici tout d’abord la documentation détaillant l’installation avec Visual Studio. Elle est très claire et vous pouvez la suivre sans mon aide, vous en avez largement les capacités.

Néanmoins, pour ceux qui se sentiraient rassurés en me voyant faire, lisez la suite. D’abord, il faut modifier les propriétés de configuration du projet, en faisant un clic-droit dessus. Tout en haut à gauche, assurez-vous d’être en mode Toutes les configurations ainsi que Toutes les plateformes.

Il y a deux choses à faire qui sont communes à debug et release.

• Dans C/C++ -> Général, dans le champ Autres répertoires Include, faites modifier, puis dans le cadre du haut mettez le chemin du dossier include du répertoire où vous avez installé SFML.
• Dans Éditeurs de liens -> Général, dans le champ Répertoires de bibliothèques supplémentaires, faites modifier, puis dans le cadre du haut mettez le chemin du dossier lib du répertoire où vous avez installé SFML.

Comme SFML est divisée en plusieurs modules, il faut ajouter plusieurs bibliothèques en particulier pour que notre code fonctionne. Dans l’étape précédente, on a indiqué au linker où chercher. Maintenant, on va indiquer exactement celles qu’on veut qu’il prenne.

Cette fois, le travail est à faire en deux fois, pour debug et pour release. Passez donc en configuration Debug puis allez dans Éditeur de liens -> Entrée. Là, modifiez le champ Dépendances supplémentaires, faites modifier puis ajouter, dans le cadre du haut, les valeurs suivantes.

• sfml-graphics-d.lib
• sfml-system-d.lib
• sfml-window-d.lib

Faite la même chose en mode Release mais prenez cette fois les versions ne contenant pas d.

• sfml-graphics.lib
• sfml-system.lib
• sfml-window.lib

La configuration du projet est terminée, mais il reste une dernière étape. SFML ayant été installée de manière dynamique, il faut ajouter les DLLs, contenues dans le dossier bin, au projet. Copiez-collez les dans le répertoire du projet et tout est bon.

Avec Qt Creator

Ouvrez votre projet, faites un clic-droit dessus et cliquez sur Ajouter une bibliothèque…. Dans la fenêtre suivante, cliquez sur Bibliothèque externe. Sur la fenêtre suivante, cliquez sur Fichier de bibliothèque puis rendez-vous dans le dossier lib de la SFML et choisissez libsfml-main.a. Dans la liste des plateformes, décochez Linux et Mac. Enfin, vérifiez que l’option Ajouter un suffixe "d" pour la version debug soit cochée.

Validez et ouvrez votre fichier .pro, que nous allons devoir modifier. De nouvelles lignes ont en effet été ajoutées.

INCLUDEPATH += $$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/include
DEPENDPATH += $$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/include

Ces lignes indiquent où chercher les fichiers d’en-tête que nous incluons, nous n’allons donc plus y toucher. Par contre, les deux autres lignes nécessitent une petite modification.

win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-main
else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-maind

La version de debug n’est pas bonne, car il manque un tiret -. Il faut donc remplacer -lsfml-maind par -lsfml-main-d. Ensuite, comme nous voulons charger d’autres modules, nous allons dupliquer ces lignes plusieurs fois, pour être en mesure d’ajouter libsfml-window, libsfml-graphics et libsfml-system. Voici les lignes à ajouter.

win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-window
else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-window-d

win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-graphics
else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-graphics-d

win32:CONFIG(release, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-system
else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/../../../../../Programmation/SFML/SFML-2.5.1-MinGW-7.3.0/lib/ -lsfml-system-d

Enfin, il reste à ajouter les DLLs au dossier de sortie. Toutes celles contenant -d vont dans le répertoire Debug, celles sans dans le répertoire Release.

Tester l’installation

Il ne reste plus qu’à tester en utilisant le code donné en exemple à la fin de la page de documentation. Si vous voyez un cercle vert s’afficher, c’est gagné.

#include <SFML/Graphics.hpp>

int main()
{
    sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");
    sf::CircleShape shape(100.f);
    shape.setFillColor(sf::Color::Green);

    while (window.isOpen())
    {
        sf::Event event;
        while (window.pollEvent(event))
        {
            if (event.type == sf::Event::Closed)
                window.close();
        }

        window.clear();
        window.draw(shape);
        window.display();
    }

    return 0;
}