Infosl

Compilation
Makefile
INFO9/10
Sébastien Lengagne
Polytech Clermont Ferrand

Génie Électrique 4A - option B
2019-2020
1 / 13
Compilation
Makefile
1 Compilation
2 Makefile
2 / 13
Compilation
Makefile
Rappels sur la compilation (C/C++)
3 / 13
Principe de fonctionnement
Compilation
Les compilateurs
Makefile
Options de Compilation
Principe de fonctionnement (Rappel)

Un compilateur est un programme qui va traduire votre code
source en un fichier contenant des instructions exécutables par le
processeur de votre ordinateur 1 . Cela se passe en plusieurs étapes :
1. https:
//openclassrooms.com/courses/c-maitriser-le-compilateur-g
4 / 13
Compilation
Les compilateurs
Makefile

1 Le préprocesseur : gestion des directives de preprocessing :
]include ]macros, ]if ...]then ...]else ,] ifdef
1. https:
4 / 13
Compilation
Les compilateurs
Makefile


2 La compilation : traduction du code vers assembleur. (c’est là
que les erreurs arrivent !)
1. https:
4 / 13
Compilation
Les compilateurs
Makefile



3 L’assemblage : transformer ce code assembleur en un fichier
objet qui contient des instructions que le processeur comprend.
1. https:
4 / 13
Compilation
Les compilateurs
Makefile




4 Le linkage : agrège chaque fichier .o avec les éventuels fichiers
binaires des librairies
1. https:
4 / 13
Compilation
Les compilateurs
Makefile




4 Le linkage : agrège chaque fichier .o avec les éventuels fichiers
binaires des librairies

Souvent les étapes 2 et 3 sont confondues en l’étape de
compilation.
1. https:
4 / 13
Compilation
Les compilateurs
Makefile
Le linkage
Le linkage 2 peut concerner :

- Une librairie dynamique (.dll et .so) n’est pas recopiée dans
l’exécutable final (ce qui signifie que le programme est plus
petit et bénéficiera des mises à jour de ladite librairie). En
contrepartie, la librairie doit être présente sur le système sur
lequel tourne le programme.
2. http://www.commentcamarche.net/faq/
14440-la-compilation-et-les-modules-en-c-et-en-c
5 / 13
Compilation
Les compilateurs
Makefile
Le linkage
Le linkage 2 peut concerner :

- Une librairie dynamique (.dll et .so) n’est pas recopiée dans
l’exécutable final (ce qui signifie que le programme est plus
petit et bénéficiera des mises à jour de ladite librairie). En
contrepartie, la librairie doit être présente sur le système sur
lequel tourne le programme.
- Une librairie statique (.a) est recopiée dans l’exécutable final
ce qui fait que celui-ci est complètement indépendant des
librairies installées du système sur lequel il sera recopié. En
contrepartie, l’exécutable est plus gros, il ne bénéficie pas des
mises à jour de cette librairie.
2. http://www.commentcamarche.net/faq/
14440-la-compilation-et-les-modules-en-c-et-en-c
5 / 13
Compilation
Les compilateurs
Makefile
Les compilateurs
gcc,
6 / 13
Compilation
Les compilateurs
Makefile
Les compilateurs
gcc,
Visual C++,
6 / 13
Compilation
Les compilateurs
Makefile
Les compilateurs
gcc,
Visual C++,
Intel C++ Compiler,
6 / 13
Compilation
Les compilateurs
Makefile
Les compilateurs
gcc,
Visual C++,
Intel C++ Compiler,
Clang,
6 / 13
Compilation
Les compilateurs
Makefile
Les compilateurs
gcc,
Visual C++,
Intel C++ Compiler,
Clang,
d’autres sur :
https://en.wikipedia.org/wiki/List_of_compilers
6 / 13
Compilation
Les compilateurs
Makefile
Il y a plusieurs options pour le compilateur :

-c : indique de ne pas linker
7 / 13
Compilation
Les compilateurs
Makefile

-v : mode verbeux. Affiche plus de détails.
7 / 13
Compilation
Les compilateurs
Makefile

-I : spécifie le ou les répertoire(s) des headers.
7 / 13
Compilation
Les compilateurs
Makefile

-Ox : indique le degré d’optimisation (x varie de 1 a 6).
7 / 13
Compilation
Les compilateurs
Makefile

-w : supprime tous les avertissements.
7 / 13
Compilation
Les compilateurs
Makefile

-Wall : GCC est très exigeant !
7 / 13
Compilation
Les compilateurs
Makefile

-Werror : tous les warnings deviennent des erreurs
7 / 13
Compilation
Les compilateurs
Makefile

-g : mode Debugger.
7 / 13
Compilation
Les compilateurs
Makefile

-g : mode Debugger.
pour en savoir plus : man gcc
7 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile
Les lignes de commandes peuvent rapidement être longue et

compliquée.
3. extrait de http://gl.developpez.com/tutoriel/outil/makefile/
8 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile

compliquée.
On utilise alors un Makefile
8 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile

compliquée.
Pour lancer : “make’’ ou “make -f fichierMakeFile”
8 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile

compliquée.
Prenons un exemple :
(Ici, on peut le compiler facilement en faisant gcc hello.c main.c
8 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile

compliquée.
Prenons un exemple :
(Ici, on peut le compiler facilement en faisant gcc hello.c main.c
mais on va voir comment le faire proprement)
Cet exemple vient du tuto : 3
8 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Présentation d’un Makefile
Un Makefile contient plusieurs règles de la forme

cible : dependance
commandes
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions

cible : dependance
commandes
Attention la tabulation est importante ! !
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions

cible : dependance
commandes
Lors de l’utilisation d’un tel fichier, la première règle est évaluée.
L’évaluation d’une règle se fait en plusieurs étapes :
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions

cible : dependance
commandes
1 Les dépendances sont analysées, si une dépendance est la
cible d’une autre règle, cette régle est à son tour évaluée.
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions

cible : dependance
commandes
2 Lorsque l’ensemble des dépendances est analysé les différentes
commandes sont exécutées.
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions

cible : dependance
commandes
2 Lorsque l’ensemble des dépendances est analysé les différentes
commandes sont exécutées.

Si la cible est plus récente que le fichier correspondant, make
n’exécute pas la commande (car déjà fait).
9 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile minimal
hello : hello.o main.o
gcc -o hello hello.o main.o
hello.o : hello.c
gcc -o hello.o -c hello.c -W -Wall -ansi -pedantic
main.o : main.c
gcc -o main.o -c main.c -W -Wall -ansi -pedantic
10 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Makefile enrichi
all : hello # permet de faire plusieurs executable
hello : hello.o main.o

gcc -o hello hello.o main.o
hello.o : hello.c
gcc -o hello.o -c hello.c -W -Wall -ansi -pedantic
main.o : main.c hello.h
gcc -o main.o -c main.c -W -Wall -ansi -pedantic
clean : #permet de supprimer les fichiers intermédiaires

rm -rf *.o
mrproper : clean # permet une reconstruction complète

rm -rf hello
11 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers
Makefile permet aussi :

l’utilisation de variables personnalisées
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers

les règles d’inférences (génériques)
%.o : %.c
commandes
la génération de liste de fichiers objets,
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers

%.o : %.c
commandes
l’ajout de conditions (si DEBUG...)
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers

%.o : %.c
commandes
l’ajout de sous makefile
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers

%.o : %.c
commandes
l’utilisation de la commande “pkgconfig” pour récupérer les
informations nécessaires
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Divers

%.o : %.c
commandes
l’utilisation de la commande “pkgconfig” pour récupérer les
informations nécessaires
Plus d’info sur :
http://gl.developpez.com/tutoriel/outil/makefile/
12 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Conclusions
Les fichiers Makefile peuvent rapidement devenir très complexes.
13 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Conclusions

Il existe des méthodes pour générer les Makefile
13 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Conclusions

Autotools : https://fr.wikipedia.org/wiki/Autotools
13 / 13
Présentation
Makefile minimal
Compilation
Makefile enrichi
Makefile
Divers
Conclusions
Conclusions

Autotools : https://fr.wikipedia.org/wiki/Autotools
CMake
13 / 13
Compilation
Makefile
Introduction
CMake est une famille d’outils open-source, multiplate-forme

conçue pour construire, tester et intégrer des logiciels.
4. https://cmake.org/
14 / 13
Compilation
Makefile
Introduction
CMake est une famille d’outils open-source, multiplate-forme

conçue pour construire, tester et intégrer des logiciels.
CMake permet de contrôler le processus de compilation du logiciel

en utilisant des fichiers de configuration indépendants de la
plate-forme et du compilateur et de générer des makefiles et des
espaces de travail qui peuvent être utilisés dans l’environnement de
compilation de votre choix. 4
4. https://cmake.org/
14 / 13
Compilation
Makefile
Introduction
En résumé CMake peut générer facilement des fichiers Makefile

ainsi que les fichiers projets pour Codeblocks (ou autre
environnement).
15 / 13
Compilation
Makefile
Syntaxe
# Ceci est un commentaire
command(argument1 argument2 ... argumentN )
COMMAND(argument1 argument2 ... argumentN)
Variables de base de cmake

CMAKE INSTALL PREFIX : répertoire d’installation (/usr/local)
16 / 13
Compilation
Makefile
Syntaxe
# Ceci est un commentaire
command(argument1 argument2 ... argumentN )
COMMAND(argument1 argument2 ... argumentN)
Variables de base de cmake

CMAKE INSTALL PREFIX : répertoire d’installation (/usr/local)
D’autres variabes :
https://cmake.org/Wiki/CMake_Useful_Variables
16 / 13
Compilation
Makefile
Exemple de base
Reprenons l’exemple Hello World et créons un CMakeLists.txt dans

le répertoire principal.
CMakeLists.txt
cmake minimum required( VERSION 2.8 )
project (hello)
add executable (Hello main.c hello.c)
17 / 13
Compilation
Makefile
Exemple de base
CMakeLists.txt
project (hello)
Il est d’usage de créer un répertoire build pour contenir les fichiers

de compilation
mkdir build ; cd build
cmake ..
make
./Hello
17 / 13
Compilation
Makefile
Exemple de base
CMakeLists.txt
project (hello)
Il est d’usage de créer un répertoire build pour contenir les fichiers

de compilation
mkdir build ; cd build
cmake -G CodeBlocks - Unix Makefiles .. # génère un .cbp
make
./Hello
17 / 13
Compilation
Makefile
Quelques options de cmake
-G CodeBlocks - Unix Makefiles # génère un .cbp
18 / 13
Compilation
Makefile
-DCMAKE BUILD TYPE=Release # Debug, RelWithDebInfo,...
18 / 13
Compilation
Makefile
-DCMAKE INSTALL PREFIX=/home/toto
18 / 13
Compilation
Makefile
-DCMAKE INSTALL PREFIX=/home/toto
-DXXX=TRUE # équivalent à #define XXX TRUE dans le code
18 / 13
Compilation
Makefile
Bonnes pratiques de code
Il est d’usage de :
faire le cmake dans un répertoire build
19 / 13
Compilation
Makefile
mettre tous les fichiers source (.c, .cpp) dans un répertoire src
19 / 13
Compilation
Makefile
mettre tous les fichiers d’entete (.hpp, .h) dans include
19 / 13
Compilation
Makefile
mettre les fichiers d’application (contenant le main) à part
(dans apps, bin, exe, ...)
19 / 13
Compilation
Makefile
mettre les fichiers de test à part (dans tests)
19 / 13
Compilation
Makefile
mettre les fichiers de test à part (dans tests)
Bien sûr il ne faut pas oublier de commenter son code ! !
Maintenant il faut adapter le CMakeLists.txt
19 / 13
Compilation
Makefile
CMakeLists.txt
project (hello)
add executable (Hello apps/main.c src/hello.c)
20 / 13
Compilation
Makefile
CMakeLists.txt
project (hello)
Le cmake se passe bien, mais le make donne une erreur.
20 / 13
Compilation
Makefile
CMakeLists.txt
project (hello)
include directories( include)
Le cmake se passe bien, mais le make donne une erreur.
20 / 13
Compilation
Makefile
Quand il y a beaucoup de fichiers à compiler, il est courant de les

rassembler en librairie.
21 / 13
Compilation
Makefile

CMakeLists.txt
project (hello)
add library(toto src/hello.c)
add executable (Hello apps/main.c)
target link libraries(Hello toto)
21 / 13
Compilation
Makefile

CMakeLists.txt
project (hello)
add library(toto SHARED src/hello.c)
21 / 13
Compilation
Makefile
Il est possible de créer Crée des variables avec les fichiers à compiler
22 / 13
Compilation
Makefile
Il est possible de créer Crée des variables avec les fichiers à compiler
CMakeLists.txt
project (hello)
set(HELLO SOURCES src/hello.c src/byebye.c ...)
add library(toto SHARED ${HELLO SOURCES})
22 / 13
Compilation
Makefile
Il est possible de rassembler tous les fichiers.
23 / 13
Compilation
Makefile

CMakeLists.txt
project (hello)
file( GLOB RECURSE HELLO SOURCES src/*.c )
file( GLOB RECURSE HELLO HEADERS include/*.h )
23 / 13
Compilation
Makefile

CMakeLists.txt
project (hello)
file( GLOB RECURSE HELLO HEADERS include/*.h )
Dans ce contexte on peut compiler sur plusieurs coeurs :

make -j X
X le nombre de coeurs à utiliser.
23 / 13
Compilation
Makefile
On peut également afficher des messages
24 / 13
Compilation
Makefile
On peut également afficher des messages

CMakeLists.txt
project (hello)
message(“les fichiers : ” ${HELLO SOURCES})
24 / 13
INFO9/10
INFO9/10

Génie Électrique 4A - option B
1 / 12
INFO9/10
1 Utilisation de librairies installées
2 / 12
INFO9/10
L’utilisation de librairies installées via cmake
3 / 12
INFO9/10
Utilisation de librairies installées :
Principe : ne pas ré-inventer la roue ! !

Votre code aura souvent besoin de librairies installées sur votre machine.
Pour pouvoir les utiliser il faut adapter votre CMakeLists.txt pour :
vérifier que les libraires sont installées : recherche
FindSUPERLIBCONFIG.cmake et met à jour se SUPERLIB FOUND,
récupérer l’emplacement des fichiers headers,
récupérer l’emplacement des librairies,
récupérer les options de compilation.
récupérer le nom des librairies pour le linkage.
CMakeLists.txt
find package( SUPERLIB REQUIRED) # ou QUIET
include directories (${SUPERLIB INCLUDE DIRS})
link directories(${SUPERLIB LIB DIRS})
add definitions (${SUPERLIB FLAGS})
target link libraries( MonExecutable ${SUPERLIB LIBRARIES} )
4 / 12
INFO9/10
Utilisation de librairies installées :
Exemple d’utilisation de librairies installées
CMakeLists.txt
cmake minimum required(VERSION 2.8)
project( DisplayImage )
find package( OpenCV REQUIRED ) # REQUIRED ou QUIET
include directories (${OPENCV INCLUDE DIRS})
add definitions (${OPENCV FLAGS})
add executable( DisplayImage apps/main.cpp )
target link libraries( DisplayImage ${OpenCV LIBS} )
5 / 12
INFO9/10
Utilisation de librairies installées : Conditions
Utilisation de conditions
CMakeLists.txt
cmake minimum required(VERSION 2.8)
project( DisplayImage )
find package( OpenCV QUIET )
if (OpenCV FOUND)
add executable( DisplayImage apps/main.cpp )
target link libraries( DisplayImage ${OpenCV LIBS} )
else (OpenCV FOUND)
message(FATAL ERROR ”opencv not found”)
endif (OpenCV FOUND)
6 / 12
INFO9/10
Utilisation de librairies installées : Conditions
L’utilisation de librairies installées via cmake
7 / 12
INFO9/10
Utilisation de librairies installées : Passage de paramètres via cmake
Passage de variable de cmake au code
On peut avoir besoin de passer des variables :

depuis la ligne de commande à cmake,
depuis cmake au code compilé.
8 / 12
INFO9/10
Passage depuis la ligne de commande
Il est possible de passer des paramètres depuis la ligne de commande :
cmake -DPARAM=POLYTECHGE ..
Certains de ces paramètres peuvent être des variable de CMake comme
CMAKE INSTALL PREFIX.
Ceci est équivalent à mettre dans le Fichier CMakeLists.txt
CMakeLists.txt
set( PARAM POLYTECHGE)
9 / 12
INFO9/10
passage depuis la ligne de commande
On peut également définir une valeur par défaut

CMakeLists.txt
if (NOT PARAM)
set (PARAM ”POLYTECHGE”)
endif()
10 / 12
INFO9/10
Passage de variable de cmake au code
version.h.in
#define VERSION MAJOR ”@HELLO VERSION MAJOR@”
CMakeLists.txt
project(hello VERSION 1.0.1)
configure file( version.h.in ${PROJECT SOURCE DIR}/include/version.h)
main.c
# include ”version.h”
...
std : :cout<<”version = ”<< VERSION MAJOR <<std : :endl ;
On a aussi accès à VERSION MINOR ou VERSION PATCH et à toutes

les variables définies dans le CMakeLists.txt
11 / 12
INFO9/10
Exercice :
passer le lien de l’image à travers le cmake pour avoir ces trois
comportements.
L’image affichée est celle par défaut (Lena.jpg).

cmake .. ./DisplayImage
on change l’image par défaut à la compilation

cmake -DIMAGE=toto.jpg .. ./DisplayImage
on change l’image à l’éxecution

cmake -DIMAGE=toto.jpg .. ou cmake .. DisplayImage tata.jpg
12 / 12
Les licences CMake installation et ré-utilisation Comment installer sans les droits admin (Linux)
INFO9/10

Génie Électrique 4A
2019-2020
séance 9
1 / 16
1 Les licences
2 CMake installation et ré-utilisation
3 Comment installer sans les droits admin (Linux)
2 / 16
Les licences
La licence est le contrat qui donne à l’utilisateur, sous condition, le

droit d’utiliser un produit logiciel 1 .
Chaque type de licence apporte un certain nombre d’avantages et
d’inconvénients à l’éditeur et à l’utilisateur.
Les contrats couvrent généralement 4 aspects :
Le droit d’utilisation,
Le droit de redistribution,
Le droit de modification,
La contrepartie financière.
1. http ://www.logidee.com/lib/exe/fetch.php/licences.pdf
3 / 16
5 catégories courantes de logiciels

les logiciels propriétaires : la licence ne permet que
l’utilisation, monopole de la distribution (copie interdite),
décompilation (pour récupérer un code source) interdite.
Les logiciels dits “du domaine public” : terme est souvent
utilisé à tort pour les logiciels libres. La convention
internationale de Berne a fixé la durée de vie des droits
d’exploitations à 70 ans (à dater de la première diffusion).
les gratuiciels (freewares) : sous-ensemble des logiciels
propriétaires (même restriction pour l’utilisateur), interdiction
de les modifier, redistribution souvent autorisée.
les partagiciels (sharewares) : logiciels propriétaires en
version d’évaluation. Si l’utilisateur est satisfait, il paie la
licence.
les logicels libres : Un logiciel libre est un logiciel dont il est
possible de modifier les sources à volonté, et de redistribuer
les modifications sans contraintes. plus value pour l’editeur :
4 / 16
la licence BSD (Berkeley Software distribution)
L’ancêtre des licences libres mise au point 1976, à

l’université de Berkeley. idées que le travail du secteur public
devrait profiter à tous.
Licence très peu restrictive autorise sans aucune restriction
la redistribution du logiciel et la création de produits dérivés.
danger : propriétarisation. rien n’interdit de réutiliser du code
sous licence BSD, d’y apporter des modifications et d’en faire
un produit propriétaire.
5 / 16
Le projet GNU
GNU est un projet de système d’exploitation libre lancé en 1983

par Richard Stallman, puis maintenu par le projet GNU.
Acronyme qui signifie en anglais ”GNU’s Not UNIX”.
Il reprend les concepts et le fonctionnement d’UNIX.
Les logiciels qui composent GNU sont généralement utilisés en
association avec des logiciels libres issus d’autres projets tels que le
noyau Linux.
6 / 16
la licence GPL : GNU General Public License
licence libre : elle permet à l’utilisateur d’accéder au code

source et de le modifier.
redistribution : rediffuser les modifications sous licence GPL.
(interdiction de le diffuser sous licence propriétaire)
licence contagieuse/contaminante : tout programme
utilisant un bout de code GPL est contaminé par la GPL.
7 / 16
la licence LGPL : GNU Lesser General Public License
Cette licence limitée, ou amoindrie, c’est-à-dire qu’elle est moins

restrictive que la licence GNU GPL dont elle découle, a été créée
pour permettre à certains logiciels libres de pénétrer tout de même
certains domaines où le choix d’une publication entièrement libre
de toute l’offre était impossible.
Cette licence s’applique souvent aux bibliothèques. La signification

originale du sigle LGPL est d’ailleurs Library General Public
License. Le sens du L de LGPL a été modifié de Library en Lesser
afin d’éviter les nombreuses inductions en erreurs.
8 / 16
d’autres licences
La WTFPL : ”Do What The Fuck You Want to Public
License” elle permet la libre redistribution et modification
d’une œuvre sans aucune restriction.
Donateware ou donationware :freeware dont la rétribution
est laissée à l’appréciation de l’utilisateur.
Careware :est un type de logiciel généralement gratuit, mais
dont l’auteur invite les utilisateurs à faire un don en faveur
d’une association caritative de son choix.
Un carticiel (postcardware ou cardware) est un partagiciel
dont l’auteur demande, pour seule rétribution d’une utilisation
régulière, l’envoi d’une carte postale.
Beerware : confère à l’utilisateur le droit d’utiliser un
programme ou de faire ce qu’il veut du code source, à
condition de conserver la même licence. Si l’utilisateur
rencontre l’auteur et considère que le logiciel de ce dernier est
utile, il est encouragé à lui offrir une bière.
9 / 16
pré-requis
Pour savoir comment installer et surtout comment ré utiliser votre

code dans un autre projet, cmake se base sur le passage de
variables.
Le code utilisé comme exemple vient du tuto

http://gl.developpez.com/tutoriel/outil/makefile/
10 / 16
Installation
CMake dispose d’une variable CMAKE INSTALL PREFIX qui

contient le chemin d’installation général. Par défaut c’est
/usr/local.
On prend l’exemple Hello.
CMakeLists.txt
add library(HelloLib SHARED src/hello.c)
target link libraries(Hello HelloLib)
install(TARGETS Hello RUNTIME DESTINATION ${CMAKE INSTALL PREFIX}/bin)
install(TARGETS HelloLib LIBRARY DESTINATION ${CMAKE INSTALL PREFIX}/lib)
install(FILES ${HELLO HEADERS} DESTINATION ${CMAKE INSTALL PREFIX}/include)
On peut aussi faire l’installation de fichiers ou de dossier.
install(FILES fichier DESTINATION dest)

install(DIRECTORY source DESTINATION dest)
11 / 16
Comment CMake trouvera votre librairie ?
Il faut expliquer à CMake comment créer un fichier

HelloConfig.cmake et l’installer afin qu’on puisse utiliser
find package.
HelloConfig.cmake.in
# - Config file for the Hello lib
# It defines the following variables
# Hello INCLUDE DIRS - include directories
# Hello LIBRARY DIRS - library directory (normally not used !)
# Hello LIBRARIES - libraries to link against
# Tell the user project where to find our headers and libraries
SET(Hello INCLUDE DIRS @CMAKE INSTALL PREFIX@/include)
SET(Hello LIBRARY DIRS @CMAKE INSTALL PREFIX@/lib)
SET(Hello LIBRARIES HelloLib)
SET(Hello FLAGS @Hello FLAGS@)
12 / 16
CMakeLists.txt
configure file(HelloConfig.cmake.in ”${PROJECT BINARY DIR}/HelloConfig.cmake” @ONLY)
install ( FILES ”${PROJECT BINARY DIR}/HelloConfig.cmake” DESTINATION

”${CMAKE INSTALL PREFIX}/lib/cmake” )
Le cmake créera le fichier HelloConfig.cmake dans le répertoire

build.
La commande make install copiera le fichier HelloConfig.cmake
dans le répertoire nécessaire (par défaut dans
/usr/local/lib/cmake)
13 / 16
CMakeLists.txt
set( CMAKE PREFIX PATH
”${CMAKE INSTALL PREFIX}/lib/cmake” )
find package (Hello Required)

...
14 / 16
Installation sans droit admin
Par défaut la variable CMAKE INSTALL PREFIX correspond au

répertoire /usr/local, qui nécessite les droits du super utilisateur
pour pouvoir y copier quelque chose.
Il est possible de faire une installation dans un autre répertoire (par
exemple /home/user/.env) et de spécifier à l’OS (linux) d’inclure
ce répertoire aux répertoires d’executable et de librairies.
pour cela :
cmake -DCMAKE INSTALL PREFIX=/home/user/.env ..

make ; make install
Les executables et librairies seront copiés dans

/home/user/.env/bin et /home/user/.env/lib
15 / 16
Installation sans droit admin
Pour qu’un terminal reconnaisse ces répertoires comme contenant

des executables et librairies :
export PATH=$PATH :/home/user/.env/bin
export LD LIBRARY PATH=$LD LIBRARY PATH :/home/user/.env/lib
Ces deux lignes peuvent être executées dans le terminal ou ajoutées au

fichier ˜/.bashrc afin que cette opération se fasse à chaque ouverture
d’un terminal.
16 / 16
INFO9/10
INFO9/10

Génie Électrique 4A
séance 12
1 / 31
INFO9/10
1 Doxygen
2 Fonctions et classes amies
3 Rappels héritage
4 Fonction virtuelle
5 Fonction virtuelle pure
6 Chargement dynamique de librairie / plugin
2 / 31
INFO9/10
Doxygen : Introduction
Doxygen : introduction
Doxygen est un générateur de documentation sous licence libre capable

de produire une documentation logicielle à partir du code source d’un
programme.
Pour cela, il tient compte de la grammaire du langage dans lequel est écrit
le code source, ainsi que des commentaires s’ils sont écrits dans un format
particulier.
Le code de Doxygen a été écrit en grande partie par Dimitri van Heesch.
3 / 31
INFO9/10
Doxygen : Utilisation via Doxywizard
Doxygen : Utilisation via Doxywizard
Tout d’abord il faut créer un répertoire doc où se situera le fichier de

configuration de doxygen.
Ce fichier de configuration peut être versionné (pas obligatoirement).
il ne faut pas versionner la documentation qui est produite.
Se placer dans doc et lancer doxywizard.
configurer puis enregistrer le fichier dans doc.
La configuration dans doxywizard se fait par des chemins relatifs
(pour permettre le portage).
On peut également générer la doc via doxygen en lancant la commande
make doc et en modifiant le CMakeLists.txt.
https://majewsky.wordpress.com/2010/08/14/
tip-of-the-day-cmake-and-doxygen
4 / 31
INFO9/10
Doxygen : Documentation du code
Diverses combinaisons sont possibles pour créer des blocs de

documentation, dans le style C ou C++ pour notre cas !
Style C avec deux *

/**
* ... Documentation ...
*/
Style C avec un !
/* !
* ... Documentation ...
*/
5 / 31
INFO9/10
Diverses combinaisons sont possibles pour créer des blocs de

documentation, dans le style C ou C++ pour notre cas !
Style C++ avec trois /

///
/// ... Documentation ...
///
Style C++ avec un !

// !
// ! ... Documentation ...
// !
6 / 31
INFO9/10
Certaines commandes sont à utiliser :

\brief : permet de créer une courte description.
\author.
\fn : pour une fonction ou une méthode
\param nom doc : pour les paramètres d’une fonction
\return : pour le retour d’une fonction ou d’une méthode.
\namespace
\date
\version
7 / 31
INFO9/10
Les classes et fonctions amies.
8 / 31
INFO9/10
Fonctions et classes amies : Rappel portée des données
example main.cpp
class MaClasse{
public :
MaClasse(){ toto = 4 ; tata = 2 ;}
∼MaClasse(){ }
void F1(){std : :cout<<MaClasse : :F1()<<std : :endl ;}
int toto ;
private :
void F2(){std : :cout<<MaClasse : :F2()<<std : :endl ;}
int tata ;
};
void main(){
MaClasse o ;
o.F1() ; // pas de problème
std : :cout<< o.toto <<std : :endl ; // pas de problème
o.F2() ; // ne compile pas
std : :cout<< o.tata <<std : :endl ; // ne compile pas
}
9 / 31
INFO9/10
Fonctions et classes amies : Introduction
a
Fonctions et classes amies
a. http://casteyde.christian.free.fr/cpp/cours/online/x3010.html
Il peut être nécessaire d’avoir des fonctions qui ont un accès illimité aux
champs d’une classe. En général, l’emploi de ces fonctions traduit un
manque d’analyse dans la hiérarchie des classes, mais pas toujours. Elles
restent donc nécessaires malgré tout.
De telles fonctions sont appelées des fonctions amies. Pour qu’une

fonction soit amie d’une classe, il faut qu’elle soit déclarée dans la classe
avec le mot clé friend.
Il est également possible de faire une classe amie d’une autre classe, mais
dans ce cas, cette classe devrait peut-être être une classe fille. L’utilisation
des classes amies peut traduire un défaut de conception.
10 / 31
INFO9/10
Fonctions et classes amies : Fonctions
Fonctions amies
Les fonctions amies ne sont pas des méthodes de la classe cependant
(cela n’aurait pas de sens puisque les méthodes ont déjà accès aux
membres de la classe).
Example amie.cpp
class A
{
int a ; // Une donnée privée.
friend void ecrit a(int i) ; // Une fonction amie.
};
A essai ;
void ecrit a(int i)
{
essai.a=i ; // Initialise a.
return ;
}
11 / 31
INFO9/10
Fonctions et classes amies : Fonctions
Fonctions amies
Généralement on utilise la notion d’amie pour surcharger l’opérateur <<
pour l’affichage.
Example amie.cpp
class A
{
int a ; // Une donnée privée.
friend std : :ostream& operator << (std : :ostream& flux,
A const& objet a) ;
};
friend std : :ostream& operator << (std : :ostream& flux,
A const& objet a)
{
flux<<“ a = ”<< objet a.a<<std : :endl ;
return flux ;
}
12 / 31
INFO9/10
Fonctions et classes amies : Classes amies
Classes amies
Pour rendre toutes les méthodes d’une classe amies d’une autre classe, il
suffit de déclarer la classe complète comme étant amie.
Pour cela, il faut encore une fois utiliser le mot clé friend avant la
déclaration de la classe, à l’intérieur de la classe cible.
Cette fois encore, la classe amie déclarée ne sera pas une sous-classe de la
classe cible, mais bien une classe de portée globale.
13 / 31
INFO9/10
Classes amies
Example amie.cpp
class Hote {
friend class Amie ; // Toutes les méthodes de Amie sont amies.
int i ; // Donnée privée de la classe Hote.
public :
Hote( ) { i=42 ; }
};
Hote h ; // variable globale
class Amie {
public :
void print hote( ) { printf(“i = %d’\n’, h.i) ; }
};
int main(void) {
Amie a ;
a.print hote() ;
return 0 ; }
14 / 31
INFO9/10
Classes amies
On remarquera plusieurs choses importantes.
Premièrement, l’amitié n’est pas transitive. (Si A est amie de B, et B

amies de C, A n’est pas amie de C par défaut) . Il faut la déclarer amie
explicitement si on désire qu’elle le soit.
Deuxièmement, les amis ne sont pas hérités. ( si une classe A est amie
d’une classe B et que la classe C est une classe fille de la classe B, alors A
n’est pas amie de la classe C par défaut). Encore une fois, il faut la
déclarer amie explicitement.
Ces remarques s’appliquent également aux fonctions amies (une fonction

amie d’une classe A amie d’une classe B n’est pas amie de la classe B, ni
des classes dérivées de A).
15 / 31
INFO9/10
Les classes abstraites
16 / 31
INFO9/10
Rappels héritage :
Rappels : création d’une classe
MaClasseMere.h MaClasseMere.cpp
class MaClasseMere ] include “MaClasseMere.h”
{
public : MaClasseMere : :MaClasseMere(){
MaClasseMere() ; ...}
∼MaClasseMere() ;
void fonction1() ; MaClasseMere : :∼MaClasseMere(){
std : :string value ; ...}
protected :
void fonction2() ; MaClasseMere : :fonction1(){
double reel ; ...}
private :
int entier ; MaClasseMere : :fonction2(){
}; ...}
17 / 31
INFO9/10
Rappels héritage :
Rappels : création d’une classe fille

On définit une classe fille.
MaClasseFille.h
] include “MaClasseMere.h”
class MaClasseFille : public : MaClasseMere
{ public :
MaClasseFille() ;
∼MaClasseFille() ;
};
Vous avez accès à ces fonctionnalités sans les re définir :

class MaClasseFille : public : MaClasseMere
{ public :
MaClasseFille() ;
∼MaClasseFille() ;
void fonction1() ;
std : :string value ;
18 / 31
INFO9/10
Fonction virtuelle :
Fonction virtuelle
Le mot-clé virtual permet de supplanter une fonction membre d’une classe

parent depuis une classe dérivée, à condition qu’elle ait la même signature.
test virtuelle.cpp
class A
{ public :
void F1() { cout<< ”A : :F1()\n” ; }
virtual void F2() { cout << ”A : :F2()\ n” ; }
};
class B : public A
{ public :
void F1() { cout << ”B : :F1()\ n” ; }
void F2() { cout << ”B : :F2()\ n” ; }
};
19 / 31
INFO9/10
Fonction virtuelle
test virtuelle.cpp ... suite

int main()
{
A a;
a.F1() ; // affiche ”A : :F1()”
a.F2() ; // affiche ”A : :F2()”
B b;
b.F1() ; // affiche ”B : :F1()”
b.F2() ; // affiche ”B : :F2()”
// copie non polymorphe

a = b;
a.F1() ; // affiche ”A : :F1()”
a.F2() ; // affiche ”A : :F2()”
20 / 31
INFO9/10
Fonction virtuelle et polymorphisme
test virtuelle.cpp ... fin

// utilisation polymorphe de B (par pointeur)
A * pa = &b ;
pa− >F1() ; // affiche ”A : :F1()”
pa− >F2() ; // affiche ”B : :F2()” < −− grâce à virtual
// utilisation polymorphe de B (par référence)

A & ra = b ;
ra.F1() ; // affiche ”A : :F1()”
ra.F2() ; // affiche ”B : :F2()” < −− grâce à virtual
}
21 / 31
INFO9/10
Fonction virtuelle pure :
Fonction virtuelle pure / classe abstraite
Une fonction virtuelle pure est une fonction qui n’est pas définie dans la
classe mère mais qui doit être définie dans les classes filles.
L’utilisation d’une fonction virtuelle pure rend la classe mère abstraite (on
ne peut pas créer un objet de la classe mère)
Concrètement, la classe Periph devrait contenir une fonction virtuelle pure

pour l’envoi et la réception d’un message. Par contre les classes PeriphI2C
et PeriphSPI doivent définir cette fonction.
22 / 31
INFO9/10
Pour déclarer une fonction virtuelle pure :

test virtuelle pure.h
class A
{ public :
virtual void F2() = 0 ;
};
class B : public A
{ public :
void F2() { cout << ”B : :F2()\ n” ; }
};
La fonction virtuelle pure n’est pas définie dans la classe mère.

On ne peut donc pas instancier un objet de la classe mère.
23 / 31
INFO9/10
test virtuelle pure.h

Que se passe-t-il dans ce cas ?
class A
{ main.cpp
public :
int main()
void F1(){F2() ;} ;
{
private :
// A a ; ne compile pas.
virtual void F2() = 0 ;
B b;
};
b.F1() ;
class B : public A
b.F2() ;
{
public :
A * pa = &b ;
private :
pa− >F1() ;
void F2() {
pa− >F2() ;
cout << ”B : :F2()\ n” ;
}
}
};
24 / 31
INFO9/10
Le chargement dynamique
25 / 31
INFO9/10
Chargement dynamique de librairie / plugin :
Chargement dynamique de librairie / plugin
Un système de plugin permet, à une application, de pouvoir charger

de façon dynamique des ”bouts de code”.
En fonction de l’implémentation du mécanisme de plugins, ces bouts
de code peuvent
être compilés (bibliothèque dynamique)
pré-compilés (un objet java)
ou via des scripts (python)
Quelque soit la forme d’un plugin, sa fonction est toujours la même,
apporter de nouvelles fonctionnalités à un programme.
Ce mécanisme permet donc de simplement rajouter des
fonctionnalités à une application, en évitant, par exemple, de
recompiler celle ci à chaque modification d’un petit bout de code.
26 / 31
INFO9/10
Télécharger le fichier exemple chargement dynamique pour étudier

comment on charge une librairie.
Reprendre le code précédent et faire le chargement dynamique des classes.
27 / 31
INFO9/10
La mise en place de l’auto complétion
28 / 31
INFO9/10
Défintion : auto-complétion
https ://www.linternaute.fr/dictionnaire : Action, pour un élément

donné, informatique ou non, de se compléter de manière automatique, par
soi-même.
Définition Mr Lengagne : action qui consiste à compléter la fin d’une

commande ou à proposer les paramètres adaptés.
En pratique, on commence à taper une commande et on utilise la touche

magique TAB pour gagner du temps et éviter les fautes de frappe.
29 / 31
INFO9/10
Pour permettre l’auto-complétion on a besoin de deux fichiers :

un fichier bash qui sera placé dans le répertoire :
/etc/bash completion.d/
un fichier executable qui donne des informations sur les paramètres
adaptés.
30 / 31
INFO9/10
Présentation de l’exemple
31 / 31

Infosl

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Infosl

Transféré par

Droits d'auteur :

Formats disponibles

Compilation

Polytech Clermont Ferrand

Rappels sur la compilation (C/C++)

Principe de fonctionnement (Rappel)

Principe de fonctionnement (Rappel)

]include ]macros, ]if ...]then ...]else ,] ifdef

Principe de fonctionnement (Rappel)

]include ]macros, ]if ...]then ...]else ,] ifdef

que les erreurs arrivent !)

Principe de fonctionnement (Rappel)

]include ]macros, ]if ...]then ...]else ,] ifdef

que les erreurs arrivent !)

objet qui contient des instructions que le processeur comprend.

Principe de fonctionnement (Rappel)

]include ]macros, ]if ...]then ...]else ,] ifdef

que les erreurs arrivent !)

objet qui contient des instructions que le processeur comprend.

binaires des librairies

Principe de fonctionnement (Rappel)

]include ]macros, ]if ...]then ...]else ,] ifdef

que les erreurs arrivent !)

objet qui contient des instructions que le processeur comprend.

binaires des librairies

Le linkage 2 peut concerner :

Le linkage 2 peut concerner :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Il y a plusieurs options pour le compilateur :

Les lignes de commandes peuvent rapidement être longue et

Les lignes de commandes peuvent rapidement être longue et

On utilise alors un Makefile

Les lignes de commandes peuvent rapidement être longue et

On utilise alors un Makefile

Pour lancer : “make’’ ou “make -f fichierMakeFile”

Les lignes de commandes peuvent rapidement être longue et

On utilise alors un Makefile

Pour lancer : “make’’ ou “make -f fichierMakeFile”

Les lignes de commandes peuvent rapidement être longue et

On utilise alors un Makefile

Pour lancer : “make’’ ou “make -f fichierMakeFile”

Cet exemple vient du tuto : 3

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

commandes sont exécutées.

Présentation d’un Makefile

Un Makefile contient plusieurs règles de la forme

commandes sont exécutées.

hello : hello.o main.o

clean : #permet de supprimer les fichiers intermédiaires