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 / 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; { // 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 / 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; // 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 / 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 (); // 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 / 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; // ajout d’un attribut chaîne de caractères }; G. Quesnel (INRA) 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
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
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
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 :: iterator it; for (it = dico. begin (); it != dico.end (); it ++) { std :: cout
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
É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 / 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 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 / 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 CMakeList.txt position.hpp G. Quesnel (INRA) Cours C++ / VLE 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 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 / 47
Vous pouvez aussi lire