Introduction au langage C++ - Adaptée à l'environnement VLE 0.6 Gauthier Quesnel - Adaptée à l'environnement VLE ...
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
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 / 47Plan
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 / 47Plan
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;
{ // un deuxième bloc
x = x + 2; // 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 Type Taille
bool un booléen [true, false]
char un entier [−128, 127]
short un entier [−215 , 215 − 1]
int un entier [−231 , 231 − 1]
long un entier [−263 , 263 − 1]
unsigned char un entier sans signe [0, 255]
unsigned short un entier sans signe [0, 216 − 1]
unsigned int un entier sans signe [0, 232 − 1]
unsigned long un entier sans signe [0, 264 − 1]
float un réel [−3.4 × 1038 , 3.4 × 1038 ]
double un réel [−1.7 × 10308 , 1.7 × 10308 ]
long double un réel [−3.4 × 104932 , 3.4 × 104932 ]
G. Quesnel (INRA) Cours C++ / VLE 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 (e < f) {
... ...
} } else if (e < g) {
...
if (c < d) { } else if (e < h) {
... ...
} else { } else {
... ...
} }
G. Quesnel (INRA) Cours C++ / VLE 9 / 47Éléments du langage C++
Les tests
Les opérateurs de comparaisons : Les combinaisons de conditions :
Opérateur Type
Opérateur Type
== égalité
and && et
!= différent
or || ou
< inférieur
xor ˆ ou exclusif
> supérieur
not ! négation
= supérieur ou égal
Exemples
if (minÉléments du langage C++
Les boucles
while for
int i = 0; for (int i = 0; i < 100; i++) {
while (i < 100) {
... ...
i++;
} }
Les trois manières de faire des
do while
boucles en C++
int i = 0;
→ point commun : le test doit
do {
... être vrai pour continuer les
i++; boucles
} while (i < 100);
G. Quesnel (INRA) 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) { // commence les tests
case INIT: // si e == INIT
...
break;
case PHASE : // si e == PHASE
...
break;
case END: // si e == END
...
break;
};
G. Quesnel (INRA) 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; // x = 10
int& y = x; // y = x
y = 4; // y = x donc x = 4
Attention Exemple
Une référence est initialisée à sa
int x = 10, z = 20;
construction, et sa valeur ne peut int& y = x;
être changée 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; // x = 10
int& y = x; // y = x
y = 4; // y = x donc x = 4
Attention Exemple
Une référence est initialisée à sa
int x = 10, z = 20;
construction, et sa valeur ne peut int& y = x;
être changée 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É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 / 47Plan
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 / 47Classes
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 / 47Classes
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 / 47Classes
Exemple complet
Classe position
class Position {
double x, y; // Définition des attributs
int numero ;
Position () : // Constructeur par défaut
x(0.0) , y(0.0) , numero (0)
{ }
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 / 47Classes
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 / 47Classes
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 / 47Classes
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 / 47Classes
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 / 47Classes
Visibilité
Exemple de visibilité
class Position {
public :
Position (int x, int y) :
m_x(x), m_y(y)
{ }
int getX (); // return m_x;
int getY (); // 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 / 47Classes
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; // ajout d’un attribut chaîne de caractères
};
G. Quesnel (INRA) Cours C++ / VLE 24 / 47Code 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 :: coutCode 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 / 47Plan
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 / 47Les 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 / 47Les 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 / 47Les 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 / 47Les 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 / 47Les 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 :: coutLes 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 :: coutLes 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 :: iterator it;
for (it = dico. begin (); it != dico.end (); it ++) {
std :: coutChaî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É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
É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
É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 / 47Plan
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 / 47Fichiers
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 position.cpp
class Position Position :: Position (int x, int y) :
{ x(x), y(x)
Position (int x, int y); { }
void move(int x, int y); Position :: move(int dx , int dy) {
x += dx;
int x, y; y += dy;
}; }
G. Quesnel (INRA) Cours C++ / VLE 40 / 47Compilation
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 / 47Compilation
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 / 47Compilation
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 / 47CMake
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 / 47CMake
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 / 47CMake
Architecture
Hiérarchie de dossiers pour construire un modèle
position
position.cpp CMakeList.txt position.hpp
G. Quesnel (INRA) Cours C++ / VLE 44 / 47CMake
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 / 47CMake
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 / 47Introduction au C++
Auteurs
Gauthier Quesnel quesnel@users.sourceforge.net
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 / 47Vous pouvez aussi lire
