Introduction au langage C++ - Adaptée à l`environnement VLE 0.6

Commentaires

Transcription

Introduction au langage C++ - Adaptée à l`environnement VLE 0.6
Introduction au langage C++
Adaptée à l’environnement VLE 0.6
Gauthier Quesnel
INRA (Institut National de la Recherche Agronomique)
G. Quesnel (INRA)
Cours C++ / VLE
1 / 47
Plan
1
Les bases
2
Classes et objets
Classes
Mot clé const
3
STL : les containers de données
Containers classiques : std::vector et std::list
Containers avancés : std::map
Chaînes de caractères : std::string
4
Compilation
Définition des fichiers
Compilation
CMake Cross-platform Make
G. Quesnel (INRA)
Cours C++ / VLE
2 / 47
Plan
1
Les bases
2
Classes et objets
Classes
Mot clé const
3
STL : les containers de données
Containers classiques : std::vector et std::list
Containers avancés : std::map
Chaînes de caractères : std::string
4
Compilation
Définition des fichiers
Compilation
CMake Cross-platform Make
G. Quesnel (INRA)
Cours C++ / VLE
3 / 47
Éléments du langage C++
Grammaire
Les commentaires, deux syntaxes possibles :
/* et */ : tout ce qui se trouve entre les deux est oublié
// : tout ce qui suit est un commentaire
Exemple
/* ceci est un commentaire sur plusieurs lignes . ceci est un
commentaire sur plusieurs lignes . ceci est un commentaire sur
plusieurs lignes . ceci est un commentaire sur plusieurs
lignes . */
// ceci est un commentaire sur une ligne
int x; // ceci est un commentaire
// ceci est un commentaire
G. Quesnel (INRA)
Cours C++ / VLE
4 / 47
Éléments du langage C++
Grammaire
Grammaire générale :
Une expression se termine par un point-virgule ;
Un bloc contient des expressions et est contenu entre { et }
Exemple
{
// ceci est un bloc
int x = 1;
x = x + 1;
{
x = x + 2;
}
// un deuxième bloc
// la variable x est toujours disponible
x = x + 1;
// x vaut 5
} // en sortie de bloque x est détruit
G. Quesnel (INRA)
Cours C++ / VLE
5 / 47
Éléments du langage C++
Les types simples (machine x86 32 bits)
Nom
bool
char
short
int
long
unsigned char
unsigned short
unsigned int
unsigned long
float
double
long double
G. Quesnel (INRA)
Type
un booléen
un entier
un entier
un entier
un entier
un entier sans signe
un entier sans signe
un entier sans signe
un entier sans signe
un réel
un réel
un réel
Cours C++ / VLE
Taille
[true, false]
[−128, 127]
[−215 , 215 − 1]
[−231 , 231 − 1]
[−263 , 263 − 1]
[0, 255]
[0, 216 − 1]
[0, 232 − 1]
[0, 264 − 1]
[−3.4 × 1038 , 3.4 × 1038 ]
[−1.7 × 10308 , 1.7 × 10308 ]
[−3.4 × 104932 , 3.4 × 104932 ]
6 / 47
Éléments du langage C++
Les types simples
Relation de tailles
1 = char ≤ short ≤ taille de int ≤ long ≤ float ≤ double ≤ long double
Attention
Une grande attention avec les réels (pour tout langage de programmation)
est obligatoire :
double x = 0.1 + 0.1 + 0.1;
double y = 0.3;
assert (x == y); // erreur x est différent de y !
G. Quesnel (INRA)
Cours C++ / VLE
7 / 47
Éléments du langage C++
Les énumérations
Une énumération est un type simple défini par l’utilisateur sous forme d’un
ensemble de valeurs :
Exemple
enum { VALEUR1 , VALEUR2 , VALEUR3 , VALEUR4 } MonType ;
MonType test1 = VALEURS1 ;
MonType test2 = VALEURS2 ;
Remarque
Les énumérations sont traduites en liste d’entiers par le compilateur C++.
La valeur de la première entité de l’ensemble est fixée à 0. (Ici VALEUR1
== 0)
G. Quesnel (INRA)
Cours C++ / VLE
8 / 47
Éléments du langage C++
Les énumérations
Une énumération est un type simple défini par l’utilisateur sous forme d’un
ensemble de valeurs :
Exemple
enum { VALEUR1 , VALEUR2 , VALEUR3 , VALEUR4 } MonType ;
MonType test1 = VALEURS1 ;
MonType test2 = VALEURS2 ;
Remarque
Les énumérations sont traduites en liste d’entiers par le compilateur C++.
La valeur de la première entité de l’ensemble est fixée à 0. (Ici VALEUR1
== 0)
G. Quesnel (INRA)
Cours C++ / VLE
8 / 47
Éléments du langage C++
Les tests
Le test conditionnel :
if : la commande de test
else : si le test échoue
else if : si le test échoue, nouvelle commande de test
Exemple
if (a < b) {
...
}
if (c < d) {
...
} else {
...
}
G. Quesnel (INRA)
if (e < f) {
...
} else if (e < g) {
...
} else if (e < h) {
...
} else {
...
}
Cours C++ / VLE
9 / 47
Éléments du langage C++
Les tests
Les opérateurs de comparaisons :
Opérateur
Type
==
égalité
!=
différent
<
inférieur
>
supérieur
<=
inférieur ou égal
>=
supérieur ou égal
Les combinaisons de conditions :
Opérateur
and &&
or ||
xor ˆ
not !
Type
et
ou
ou exclusif
négation
Exemples
if (min <= x and x <= max) { ...
if (x < 10 or y < 10) { ...
if (( min <= x and x <= max) or (min <= y and y <= max )) { ...
G. Quesnel (INRA)
Cours C++ / VLE
10 / 47
Éléments du langage C++
Les boucles
while
for
int i = 0;
while (i < 100) {
...
i++;
}
for (int i = 0; i < 100; i++) {
do while
int i = 0;
do {
...
i++;
} while (i < 100);
G. Quesnel (INRA)
...
}
Les trois manières de faire des
boucles en C++
→ point commun : le test doit
être vrai pour continuer les
boucles
Cours C++ / VLE
11 / 47
Éléments du langage C++
Le choix
Tester les valeurs par rapport à un ensemble de constante (ne fonctionne
que pour les types entiers et les énumérations)
Exemple
enum { INIT , PHASE1 , END } MonEnum ;
MonEnum e;
// déclaration d’une variable basée sur l’énumération
switch (e) {
case INIT:
...
break;
case PHASE :
...
break;
case END:
...
break;
};
// commence les tests
// si e == INIT
G. Quesnel (INRA)
// si e == PHASE
// si e == END
Cours C++ / VLE
12 / 47
Éléments du langage C++
Les références
Définition
Une référence, définie par le & est un nouveau nom pour une variable,
c-à-d, un simple alias
Exemple
int x = 10;
int& y = x;
y = 4;
// x = 10
// y = x
// y = x donc x = 4
Attention
Exemple
Une référence est initialisée à sa
construction, et sa valeur ne peut
être changée
int x = 10, z = 20;
int& y = x;
y = z;
// y = x donc x = 20 !
G. Quesnel (INRA)
Cours C++ / VLE
13 / 47
Éléments du langage C++
Les références
Définition
Une référence, définie par le & est un nouveau nom pour une variable,
c-à-d, un simple alias
Exemple
int x = 10;
int& y = x;
y = 4;
// x = 10
// y = x
// y = x donc x = 4
Attention
Exemple
Une référence est initialisée à sa
construction, et sa valeur ne peut
être changée
int x = 10, z = 20;
int& y = x;
y = z;
// y = x donc x = 20 !
G. Quesnel (INRA)
Cours C++ / VLE
13 / 47
Éléments du langage C++
Les fonctions
Définition
Une fonction est une partie nommée d’un programme que l’on peut
appeler d’autres parties du programme aussi souvent que nécessaire
Exemples
// Déclaration d’une fonction à deux arguments réels , x et y, et qui
// retourne à la fonction l’appelant la somme de ces deux réels
double somme ( double x, double y) {
return x + y;
}
// Une fonction qui affiche le couple (x, y) et la somme de ces
// deux chiffres
void show( double x, double y) {
std :: cout << "(x:" << x << ", y:" << y << ")";
std :: cout << " somme : " << somme (x, y);
}
G. Quesnel (INRA)
Cours C++ / VLE
14 / 47
Éléments du langage C++
Les espaces de noms
Définition
Un espace de noms est un mot clé associé à un ensemble de types C++
afin d’éliminer les problèmes de définition multiples
Exemples
namespace test {
void toto ()
{
}
}
namespace test2 {
void toto ()
{
}
}
G. Quesnel (INRA)
Cours C++ / VLE
15 / 47
Éléments du langage C++
Les espaces de noms
Exemples
// Utilisation des namespaces
test :: toto ();
test2 :: toto ();
using namespace test; // demande au compilateur d’utiliser test
// dans l’espace de nom global
toto ();
Remarques
L’espace de nom de la bibliothèque C++ est std.
L’espace de nom de la bibliothèque VLE est vle.
G. Quesnel (INRA)
Cours C++ / VLE
16 / 47
Plan
1
Les bases
2
Classes et objets
Classes
Mot clé const
3
STL : les containers de données
Containers classiques : std::vector et std::list
Containers avancés : std::map
Chaînes de caractères : std::string
4
Compilation
Définition des fichiers
Compilation
CMake Cross-platform Make
G. Quesnel (INRA)
Cours C++ / VLE
17 / 47
Classes
Définition
Définition
Une classe est une entité ou structure informatique dont le but est de
simplifier, améliorer et de mieux structurer les développements
informatique
En C++, une classe est définie par :
le mot clé class (Ex. : class Position)
d’une ou plusieurs fonctions constructeurs (Ex. : Position())
d’un destructeur (Ex. : ˜Position())
d’attributs de types simples, composés, de classes etc.
de méthodes pour manipuler les attributs
G. Quesnel (INRA)
Cours C++ / VLE
18 / 47
Classes
Définition
Exemple d’une classe minimaliste
class Test {
};
Pour cette classe vide, le langage C++ fournit des fonctions par défaut :
Classe générée par le C++
class Test {
Test () { }
// constructeur
par défaut
Test( const Test& test) { }
// constructeur
par recopie
~Test () { }
// le destructeur
Test& operator =( const Test& test) // l’opérateur d’affectation
{ return test; }
};
G. Quesnel (INRA)
Cours C++ / VLE
19 / 47
Classes
Exemple complet
Classe position
class Position {
double x, y;
int
numero ;
// Définition des attributs
Position () :
x(0.0) , y(0.0) , numero (0)
{ }
// Constructeur par défaut
Position ( double x, double y) : // Constructeur supplémentaire
x(x), y(y), numero (0)
{ }
Position (const Position & pos) : // Constructeur par recopie ,
x(pos.x), y(pos.y), numero (pos. numero ) // fourni par défaut
{ }
};
G. Quesnel (INRA)
Cours C++ / VLE
20 / 47
Classes
Exemple complet
Une classe pour être utilisable, doit être instanciée (c-à-d, créée) :
Instantiation d’une classe
void creer_position () {
Position p1;
// Création d’un objet Position avec l’appel au
// constructeur par défaut (x = 0.0 , y = 0.0)
Position p2 (1. , 2.); // Création d’un objet Position avec l’appel au
// constructeur à deux réels (x = 1.0 , y = 2.0)
Position p3(p1 );
// Création d’un objet Position avec l’appel du
// constructeur par recopie
}
Remarque
Les objets ci-dessus seront détruits à la sortie de la fonction, comme tout
autre objet, type simple ou composé alloué dans un bloc.
G. Quesnel (INRA)
Cours C++ / VLE
21 / 47
Classes
Exemple complet
Une classe pour être utilisable, doit être instanciée (c-à-d, créée) :
Instantiation d’une classe
void creer_position () {
Position p1;
// Création d’un objet Position avec l’appel au
// constructeur par défaut (x = 0.0 , y = 0.0)
Position p2 (1. , 2.); // Création d’un objet Position avec l’appel au
// constructeur à deux réels (x = 1.0 , y = 2.0)
Position p3(p1 );
// Création d’un objet Position avec l’appel du
// constructeur par recopie
}
Remarque
Les objets ci-dessus seront détruits à la sortie de la fonction, comme tout
autre objet, type simple ou composé alloué dans un bloc.
G. Quesnel (INRA)
Cours C++ / VLE
21 / 47
Classes
Visibilité
Afin de structurer le code de programme objet de manière plus élégante,
trois attributs de visibilité sont proposés :
1
public : les fonctions, les attributs sont accessibles par n’importe quel
autre code.
2
protected : les fonctions, les attributs sont accessibles uniquement
aux classes qui héritent de cette classes.
3
private : personne n’a accès aux éléments de la classe.
Règles
Les attributs sont de visibilité private
Réduire au maximum les accès à la visibilité public
G. Quesnel (INRA)
Cours C++ / VLE
22 / 47
Classes
Visibilité
Afin de structurer le code de programme objet de manière plus élégante,
trois attributs de visibilité sont proposés :
1
public : les fonctions, les attributs sont accessibles par n’importe quel
autre code.
2
protected : les fonctions, les attributs sont accessibles uniquement
aux classes qui héritent de cette classes.
3
private : personne n’a accès aux éléments de la classe.
Règles
Les attributs sont de visibilité private
Réduire au maximum les accès à la visibilité public
G. Quesnel (INRA)
Cours C++ / VLE
22 / 47
Classes
Visibilité
Exemple de visibilité
class Position {
public :
Position (int x, int y) :
m_x(x), m_y(y)
{ }
int getX ();
int getY ();
// return m_x;
// return m_y;
void move(int dx , int dy ); // m_x += dx , m_y += dy
private :
void setPosition (int x, int y); // m_x = x, m_y = y
int m_x , m_y;
};
Ici, l’utilisateur de la classe est limitée à la fonction move pour modifier les
attributs de la classe
G. Quesnel (INRA)
Cours C++ / VLE
23 / 47
Classes
Héritage
Le concept d’héritage permet d’améliorer une classe existante en :
surchargeant les méthodes existantes si la visibilité le permet
permet d’agréger des comportements et les données de classes
spécialisant un objet dans une tâche
Exemple
class Position {
...
};
class PositionNommee : public class Position {
...
const std :: string getName () const
// ajout d’une méthode
{ return name; }
// retournant cette chaîne de caractères
private :
std :: string name;
};
G. Quesnel (INRA)
// ajout d’un attribut chaîne de caractères
Cours C++ / VLE
24 / 47
Code constant
Le mot clé const
Variable, attribut etc. : ne peut modifier le contenu
Exemples
const int toto = 12;
toto = 13;
// erreur de compilation
void addExtensionRdata (const std :: string & filename )
{
filename += ". rdata "; // erreur de compilation
}
void show(const std :: vector < int >& tab)
{
std :: vector < int >:: const_iterator it;
for (it = tab. begin (); it != tab.end (); it ++) {
std :: cout << *it << "\n";
}
}
G. Quesnel (INRA)
Cours C++ / VLE
25 / 47
Code constant
Le mot clé const
Fonction membre d’une classe : ne peut modifier les membres de la
classe
Exemple
class Position {
public :
void setPosition ( double x, double y) const {
m_x = x;
// erreur de compilation , la fonction
m_y = y;
// setPosition est constante
}
private :
double m_x;
double m_y;
};
G. Quesnel (INRA)
Cours C++ / VLE
26 / 47
Plan
1
Les bases
2
Classes et objets
Classes
Mot clé const
3
STL : les containers de données
Containers classiques : std::vector et std::list
Containers avancés : std::map
Chaînes de caractères : std::string
4
Compilation
Définition des fichiers
Compilation
CMake Cross-platform Make
G. Quesnel (INRA)
Cours C++ / VLE
27 / 47
Les containers classiques
Les tableaux : std::vector
Le vecteur en C++ représente un tableau C :
Allocation dynamique de la mémoire (std::malloc)
Ré-allocation dynamique de la mémoire (std::realloc)
Accès directe aux données du tableau (operator[])
Modifications de la taille sont coûteuses
Allocation
// allocation d’un tableau
std :: vector < int > tableau ;
// allocation d’un tableau de 100 double initialisé à 0.
std :: vector < double > tableau (100 , 0);
// allocation d’un tableau de 100 Objet initialisé par le
// constructeur par défaut de l’objet Objet .
std :: vector < Objet > tableau (100 , 0);
G. Quesnel (INRA)
Cours C++ / VLE
28 / 47
Les containers classiques
Les tableaux : std::vector
Réallocation
// création d’un tableau de réels
std :: vector < double > tableau ;
// positionne la taille à 100 réels
tableau . resize (100);
// réduit la taille à 10 réels
tableau . resize (10);
// ajout de 90 réels : 1, 2, 3 etc.
for (int i = 0; i < 90; ++i) {
tableau . push_back (i);
}
G. Quesnel (INRA)
Cours C++ / VLE
29 / 47
Les containers classiques
Les tableaux : std::vector
Accès aux données
// assigne un numéro à chaque élément du tableau
std :: vector < double > tab (100);
for (int i = 0; i < tab.size (); i++) {
tab[i] = i;
}
// le même parcours par les itérateurs
int i = 0;
std :: vector < double >:: iterator it;
for (it = tab. begin (); it != tab.end (); it ++) {
*it = i;
i++;
}
G. Quesnel (INRA)
Cours C++ / VLE
30 / 47
Les containers classiques
Les listes chaînées : std::list
Les listes chaînées, pour des ajouts et suppression rapide :
Allocation dynamique de la mémoire
Allocation
// définition d’une liste chaînées de réels
std :: list < double > lst;
// création d’une liste chaînée 1.0 , 2.0 , 3.0
lst. push_back (2.0);
lst. push_front (1.0);
lst. push_back (3.0);
G. Quesnel (INRA)
Cours C++ / VLE
31 / 47
Les containers classiques
Les listes chaînées : std::list
Accès aux données
// Définition d’une liste chaînées d’objets
std :: list < Object > lst;
[...]
// Affiche tous les objets de la liste chaînée
std :: list < Object >:: iterator it;
for (it = lst. begin (); it != lst.end (); ++ it) {
std :: cout << *it << "\n";
}
//
//
it
if
Recherche un objet dans la list équal à Object (" test ")
surcharge de l’opérateur ==
= std :: find(lst. begin (), lst.end (), Object ("test"));
(it == lst.end ()) {
std :: cout << " Objet non trouvé \n";
} else {
std :: cout << " Objet trouvé \n";
}
G. Quesnel (INRA)
Cours C++ / VLE
32 / 47
Les containers avancés
Les tableaux : associatifs : std::map
Une sorte de dictionnaire : à une clé on attache une valeurs
la clé peut être de tous type s’il existe l’opérateur de comparaison
la donnée est quelconque
Ajout de données
// Création d’un dictionnaire dont le type de la clé est
// une chaîne de caractères et de données de type réelles .
std :: map < std :: string , double > dico;
dico["a"] = 1.0;
dico["toto"] = 0.125;
std :: cout << dico["toto"] << "\n"; // affiche 1.0
std :: cout << dico["titi"] << "\n"; // affiche 0.0 , titi n’existe
// pas mais il est créé
G. Quesnel (INRA)
Cours C++ / VLE
33 / 47
Les containers avancés
Les tableaux : associatifs : std::map
Tester l’existence d’une clé
std :: map < std :: string , int > dico;
[...]
std :: map < std :: string , int >:: iterator it = dico.find(" cherche ");
if (it == dico.end ()) {
std :: cout << "La clé n’existe pas dans le dico.";
}
Parcours linéaire
std :: map < std :: string , int >:: iterator it;
for (it = dico. begin (); it != dico.end (); it ++) {
std :: cout << "clé ......: " << it -> first
<< " valeur ...: " << it -> second
<< "\n";
}
G. Quesnel (INRA)
Cours C++ / VLE
34 / 47
Chaînes de caractères
Utilisations courantes
La classe std::string encapsule un tableau de char.
Gestion complète de l’allocation, ré-allocation
Nombreuses fonctions de parcours
Manipulation de chaînes
std :: string str1 = "test";
std :: string str2(" test2 ");
std :: string str3 = str1 + str2;
int pos = str2.find("2");
for (int i = 0; i < str3.size (); i++) {
std :: cout << str2[i] << "\n";
}
G. Quesnel (INRA)
Cours C++ / VLE
35 / 47
Éléments du langage C++
Les entrées / sorties
Le langage défini les entrées sorties sous forme d’objets et via l’utilisation
des opérateurs operator« et operator» :
Sortie dans la console et dans un fichier
int i = 13;
double j = 3.1415;
// sortie dans la console
std :: cout << " Sortie standard " << i << " " << j << std :: endl;
// sortie dans un fichier nommé out.dat
std :: ofstream fichier ("out.dat");
fichier << " Sortie standard " << i << " " << j << std :: endl;
Remarque
Ajouter un retour à la ligne est réalisé par un caractère
n ou via std::endl. Ce dernier vide également les caches
G. Quesnel (INRA)
Cours C++ / VLE
36 / 47
Éléments du langage C++
Les entrées / sorties
Le langage défini les entrées sorties sous forme d’objets et via l’utilisation
des opérateurs operator« et operator» :
Sortie dans la console et dans un fichier
int i = 13;
double j = 3.1415;
// sortie dans la console
std :: cout << " Sortie standard " << i << " " << j << std :: endl;
// sortie dans un fichier nommé out.dat
std :: ofstream fichier ("out.dat");
fichier << " Sortie standard " << i << " " << j << std :: endl;
Remarque
Ajouter un retour à la ligne est réalisé par un caractère
n ou via std::endl. Ce dernier vide également les caches
G. Quesnel (INRA)
Cours C++ / VLE
36 / 47
Éléments du langage C++
Les entrées / sorties
Entrée depuis la console ou depuis un fichier
double x, double y;
// récupération depuis la console
std :: cin >> x >> y;
// récupération depuis un fichier
std :: ifstream fichier ("out.dat");
fichier >> x >> y;
Remarque
Pour lire une ligne entière d’un fichier on utilise
std::getline(std::ostream&, std::string)
G. Quesnel (INRA)
Cours C++ / VLE
37 / 47
Éléments du langage C++
Les entrées / sorties
F.: L’arbre d’héritage des flux (sources : http://www.cplusplus.com)
G. Quesnel (INRA)
Cours C++ / VLE
38 / 47
Plan
1
Les bases
2
Classes et objets
Classes
Mot clé const
3
STL : les containers de données
Containers classiques : std::vector et std::list
Containers avancés : std::map
Chaînes de caractères : std::string
4
Compilation
Définition des fichiers
Compilation
CMake Cross-platform Make
G. Quesnel (INRA)
Cours C++ / VLE
39 / 47
Fichiers
Quelques règles en C++ :
Un fichier d’extension « .hpp » pour les déclarations
Un fichier d’extension « .cpp » pour les définitions
position.hpp
class Position
{
Position (int x, int y);
void move(int x, int y);
int x, y;
};
G. Quesnel (INRA)
position.cpp
Position :: Position (int x, int y) :
x(x), y(x)
{ }
Position :: move(int dx , int dy) {
x += dx;
y += dy;
}
Cours C++ / VLE
40 / 47
Compilation
Comment compiler ?
Définition
La compilation permet de rendre le code C++ compréhensible par le
système d’exploitation
Comment compiler ? (Unix/Linux/Windows/Gcc)
$ g++ -c position .cpp
# génération d’un fichier position .o
Comment créer un exécutable ? (Unix/Linux/Window/Gcc)
$ g++ -c position .cpp
# génération d’un fichier position .o
$ g++ -c main.cpp
# génération d’un fichier main.o
$ g++ -o executable position .o main.o # création exécutable à partir
# des fichiers .o
G. Quesnel (INRA)
Cours C++ / VLE
41 / 47
Compilation
Bibliothèques dynamiques
Définition
Une bibliothèque dynamique permet de partager du code compiler entre
plusieurs applications
Comment créer une bibliothèque dynamique ? (Unix/Linux/Gcc)
$ gcc -c position .cpp
$ gcc -shared position .o -o libposition .so
Comment se lier avec ? (Unix/Linux/Gcc)
$ gcc -c main.cpp
$ gcc -o executable main.o -lposition -L.
→ Travail pénible à réaliser : passage à CMake
G. Quesnel (INRA)
Cours C++ / VLE
42 / 47
Compilation
Bibliothèques dynamiques
Définition
Une bibliothèque dynamique permet de partager du code compiler entre
plusieurs applications
Comment créer une bibliothèque dynamique ? (Unix/Linux/Gcc)
$ gcc -c position .cpp
$ gcc -shared position .o -o libposition .so
Comment se lier avec ? (Unix/Linux/Gcc)
$ gcc -c main.cpp
$ gcc -o executable main.o -lposition -L.
→ Travail pénible à réaliser : passage à CMake
G. Quesnel (INRA)
Cours C++ / VLE
42 / 47
CMake
Génération automatique de Makefile
Définition
CMake se définit comme un système open-source et multi-plateforme de
construction
Son but, contrôler la compilation d’un logiciel en :
fournissant des outils portables de détection de compilateur, d’options
de compilation, etc.
générant des fichiers Makefile natifs pour les différents compilateurs
acceptés
proposant des tests de détection de bibliothèques etc.
Important
L’exemple qui suit est adapté au développement de modèle sous
l’environnement VLE : le code source position sera vu comme un
modèle
G. Quesnel (INRA)
Cours C++ / VLE
43 / 47
CMake
Génération automatique de Makefile
Définition
CMake se définit comme un système open-source et multi-plateforme de
construction
Son but, contrôler la compilation d’un logiciel en :
fournissant des outils portables de détection de compilateur, d’options
de compilation, etc.
générant des fichiers Makefile natifs pour les différents compilateurs
acceptés
proposant des tests de détection de bibliothèques etc.
Important
L’exemple qui suit est adapté au développement de modèle sous
l’environnement VLE : le code source position sera vu comme un
modèle
G. Quesnel (INRA)
Cours C++ / VLE
43 / 47
CMake
Architecture
Hiérarchie de dossiers pour construire un modèle
position
position.cpp
G. Quesnel (INRA)
CMakeList.txt
Cours C++ / VLE
position.hpp
44 / 47
CMake
Que faire ?
position : le nom de la bibliothèque qui sera créée à partir des codes
sources (les fichiers position.hpp et position.cpp)
I position :
I libposition.so sous GNU/Linux
I libposition.dll sous Windows
I libposition.dylib sous MacOS
position.hpp, position.hpp : les sources
CMakeLists.txt : le fichier général du projet
G. Quesnel (INRA)
Cours C++ / VLE
45 / 47
CMake
Comment utiliser ?
La génération du projet consiste à détecter l’environnement, les
compilateurs, les bibliothèques etc.
Génération du projet
Première génération :
$ cd modele
$ cmake -DCMAKE_INSTALL_PREFIX = $HOME /usr . # linux , macos
$ cmake -DCMAKE_INSTALL_PREFIX =% HOMEDRIVE %% HOMEPATH %\ vle . # windows
Par la suite, pour le développement du modèle, il suffit simplement de
taper les commandes :
L’après génération du projet
$ make / mingw32 -make
$ make install / mingw32 -make install
G. Quesnel (INRA)
Cours C++ / VLE
46 / 47
Introduction au C++
Auteurs
Gauthier Quesnel [email protected]
Licence
Copyright (C) 2008 - INRA
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy
of the license is included in the section entitled "GNU Free Documentation
License".
G. Quesnel (INRA)
Cours C++ / VLE
47 / 47

Documents pareils