Ce tutoriel implante les classes personnalisés
Liens Vers les autres tutoriels de la série :
Bioopo
Le 31/12/2006
Nous allons commencer ce tutoriel par un bug. Et oui, j'ai oublié de programmer la fonction qui vérifie les décimales, donc nous avions un bug quand un nombre avait plusieurs décimales. Nous le corrigerons dans ce tutoriel.
La grande innovation et la seule chose que nous allons découvrir dans ce tutoriel est une des plus grandes bases à acquérir du c++, la création de classes. Comme le c++ est un programme orienté objet, les classes sont primordiales dans un projet. Elles vous faciliteront la conception du projet.
Voilà, ça sera la base pour notre mise a jour. Fixons les buts clairement :
Les connaissances requises sont celles acquises aux tutoriels numéros 1 à 3 : Débutez en c++. Il faut savoir :
Le but du programme est d'afficher le résultat d'une opération saisie par l'utilisateur.
Nous allons utiliser le logiciel dev-c++ avec un nouveau projet en mode console.
Pourquoi le mode console?
Simplement car pour la calculatrice que nous allons programmer, une interface graphique est inutile. Surtout, elle nous rendrait l'apprentissage plus difficile, ce qui n'est pas le but. L'exécutable de la calculatrice ne devra pas dépasser 500 Ko.
Conception du programme à l'aide des classes. Changement de la structure du programme.
Pour ce tutoriel, nous ne devons rien modifier dans l'analyse fonctionnelle, mais seulement l'analyse structurelle de notre projet initial.
Spécificités | Détails |
---|---|
Code d'identification | FP0 |
Nom | Calculatrice |
Objectif | Afficher le résultat d'une opération saisie par l'utilisateur |
Données fournies | Aucune |
Actions utilisateur | Saisie de l'opération |
Données sorties | Résultat de l'opération |
Sous-fonctions | FP1 : Enregistrement saisie FP2 : Calcul FP3 : Affichage du résultat FP4 : Vérification des saisies FA1 : Menu |
Description détaillée | La calculatrice devra, en fonction de la saisie de l'utilisateur, calculer et afficher le résultat de l'opération. |
Les classes sont des objets, qui regroupent des variables et des fonctions. Pour donner un exemple, prenons le cas d'une voiture :
Nous définissons une voiture comme une classe (objet). La voiture (peu importe la marque et le modèle) a des données communes à chaque modèles, sa vitesse, son poids, sa taille, le nombre de litres d'essence que le réservoir peut contenir...., ainsi que des actions communes que la voiture peut faire : démarrer, avancer, reculer, tourner, arrêter....
Nous disons que la classe voiture à des variables membres. Ce sont les données communes, et des méthodes (fonctions) ce sont les actions à réaliser.
Nous avons la définition d'un objet voiture qui définit une globalité. Toutes les voitures ont ces caractéristiques. Ce qui les différenciera, ce sont les valeurs de ces caractéristiques.
Prenons l'exemple d'une Renault Mégane et d'une Porsche 911.
Ce sont deux voitures avec des caractéristiques différentes. Alors nous pouvons dire que la Renault est une instance de la classe voiture et La Porsche une seconde.
Pour faire plus clair, imaginons que nous avons une centaine de voitures. Pour définir chaque voiture sans les classes, il nous faudrait des centaines de variables et des milliers de lignes de code supplémentaires. Bonjour l'angoisse. Alors qu'avec les classes, nous définissons les caractéristiques d'un objet voiture une seule fois, puis nous définirons des instances de celle-ci. Ce qui fera gagner des milliers de ligne de code, de la simplicité et un langage orienté objet.
Au stade de notre programme, la création d'une classe pour la calculatrice peut paraitre inutile, et vous avez raison. Le programme fonctionne très bien. Il est déjà simple et ajouter des fichiers ne sert pas à grand chose. Mais vous êtes dans une série de tutoriels, nous sommes là pour apprendre. Et, de plus, nous en aurons besoin plus tard, quand nous partirons vraiment vers de la programmation objet pure. Pour le moment, nous allons nous contenter de créer la classe, et de recopier le code avec des petites modifications, pour comprendre le fonctionnement d'une classe.
Dans le prochain tutoriel, nous définirons une vrai structure orientée objet, nous modifierons la façon de concevoir une calculatrice, la façon dont les différentes parties interagissent entre elles et nous ajouteront quelques fonctions à la calculatrice pour finir ce projet.
Je ne développerais pas plus ici les notions de classe, je préfère vous les donner concrètement avec l'exemple du projet. Nous ne verrons que les bases de création et d'utilisation, pas les fonctions avancées.
Nous commençons le développement avec la création de la classe cCalculatrice. Par convention, le nom d'une classe commence par un c, mais nous reparlerons des conventions de nommage des classes dans la partie Compléments.
Ouvrez votre projet dev-c++, cliquez sur l'onglet classe dans la partie gauche. Faites un clic droit, sur le blanc, puis cliquez sur nouvelle classe. Une fenêtre va s'ouvrir, entrez le nom de la classe : cCalculatrice puis cliquez sur OK. Ensuite enregistrez les fichiers.
Votre classe se trouve dans les fichiers ccalculatrice.h et ccalculatrice.cpp. Commençons par supprimer les commentaires par créés par dev-c++ et ajoutons les nôtres.
Fichier ccalculatrice.h
/********************************** Program : calc2007 Fichier : ccalculatrice.h Créateur : bioopo Creation : 31/12/2006 logiciel : dev-c++ Version : 0.1b Modification : 31/12/2006 **********************************/ /********************************** Cette classe contient les fonctions de la calculatrice **********************************/ #ifndef CCALCULATRICE_H #define CCALCULATRICE_H /********************************** Définition de la classe cCalculatrice **********************************/ class cCalculatrice { public: //Constructeur de la classe cCalculatrice(); //Destructeur de la classe ~cCalculatrice(); }; #endif
Fichier ccalculatrice.cpp
/********************************** Program : calc2007 Fichier : ccalculatrice.h Créateur : bioopo Creation : 31/12/2006 logiciel : dev-c++ Version : 0.1b Modification : 31/12/2006 **********************************/ /********************************** Cette classe contient les fonctions de la calculatrice **********************************/ /********************************** Fichiers a inclure **********************************/ #include "ccalculatrice.h" /********************************** Constructeur de classe **********************************/ cCalculatrice::cCalculatrice() { } /********************************** Destructeur de classe **********************************/ cCalculatrice::~cCalculatrice() { }
Voila, regardons de plus près ces fichiers. Dans le fichier main.h, il y a une fonction ifndef - define - endif. Elle est nécessaire, elle permet de ne pas l'inclure plusieurs fois dans l'exécutable du programme.
Ensuite, il y a le constructeur de classe. Cette fonction est particulière, elle est appelée à la création d'une instance de classe, pour créer celle-ci. Alors que le destructeur est appelé quand nous détruisons cette instance de classe.
Le mot clé public fait partie des mots clés définissant la protection des méthodes (fonctions) et des membres (variables) de la classe. Ce mot signifie que les méthodes et les membres définis public sont visibles par le reste du programme. Private signifie qu'elles ne sont visibles qu'à l'intérieur de la classe. Il y a aussi le mot protected que nous ne verrons pas ici.
Normalement, dans la phase d'analyse, nous déterminons les besoins de méthodes et de membres pour les classes. Ici, nous nous contenterons de recopier et modifier légèrement le code du tutoriel précédent. Je ne passerais pas par les fonctions de dev-c++ pour définir les méthode et les membres, Nous écrirons et positionnerons nous même tout cela.
Commençons par inclure les membres de cette classe.
Fichier ccalculatrice.h
......
class cCalculatrice { public: //Constructeur de la classe cCalculatrice(); //Destructeur de la classe ~cCalculatrice(); /********************************** Définition des variables **********************************/ private: //Variable contenant la saisie de l'opérateur. std::string m_strSaisie; //variable contenant le signe de l'opération std::string m_strOperand[10]; //Variable contenant les nombres de l'opération double m_dblNombre[10]; //Variable contenant le résultat double m_dblResultat; //variable de présence d'erreur bool m_bErreur; //variable de présence de décimal bool m_bDecimal; //Variable de menu int m_intMenu; }; #endif
Continuons avec les méthodes de la classe
Fichier ccalculatrice.h
......
//Variable de menu int m_intMenu; /********************************** Déclaration des fonctions **********************************/ public: //Fonction d'initialisation de la calculatrice void Initialisation(); private: //Fonction permettant la saisie utilisateur void Saisie_Utilisateur(); //Fonction permettant la vérification de la saisie utilisateur void Verification_Saisie(); //Fonction permettant d'extraire les différentes partie de l'opération. void Extraction(); //fonction de calcul de l'opération void Calcul(); //Fonction de menu void Menu(); }; #endif
Voila. Pour faire simple, nous avons copié les variables du fichier main.h. Nous les avons renommées pour être dans la convention de nommage et nous les avons placés en private. Cela signifie que seules les méthodes de la classe y auront accès. Pour les méthodes, c'est la même chose, à part que nous ne les renommons pas. Vous pouvez voir qu'une seule fonction est public. Cela signifie que c'est la seule fonction que l'on peut appeler en dehors de la classe. C'est la seule fonction que la fonction main peut appeler. Les autres fonctions ne peuvent être appelées qu'à partir de la classe.
A quoi cela peut-il servir?
Et bien tout simplement à protéger les données.
Nous allons maintenant inclure (comme dans la fonction main ) les fichiers dont nous avons besoin.
Fichier ccalculatrice.cpp
......
/********************************** Cette classe contient les fonctions de la calculatrice **********************************/ /********************************** Fichiers a inclure **********************************/ #include <cstdlib> #include <iostream> #include <sstream> #include <string> #include "ccalculatrice.h" /********************************** Utilisation de l'espace de noms standard **********************************/ using namespace std; /********************************** Constructeur de classe **********************************/
......
Voila, nous pouvons donc commencer à recopier et modifier le code.
Fichier ccalculatrice.cpp - Fin du fichier
......
/********************************** Fonction Initialisation Fonction initialisant la calculatrice **********************************/ void cCalculatrice::Initialisation() { cout << "Bioopo-vega calculatrice 2007 version 0.2a" << endl; Menu(); while(m_intMenu != 2) { if(m_intMenu == 1) { system("cls" ); cout << "entrez l'operation" << endl; Saisie_Utilisateur(); //Fonction de vérification de la saisie Verification_Saisie(); //fonction d'extraction des données de l'opération Extraction(); //Fonction de calcul de l'opération Calcul(); //Fonction affichant le résultat de l'opération à l'écran cout << "Le resultat est" << endl; cout << m_dblResultat << endl; system("PAUSE"); Menu(); } else Menu(); } if(m_intMenu == 2) { //Appel de la fonction demandant une pause et de presser une touche pour quitter. system("PAUSE"); } } /********************************** Fonction Saisie_Utilisateur Fonction permettant la saisie utilisateur **********************************/ void cCalculatrice::Saisie_Utilisateur() { cin >> m_strSaisie; } /********************************** Fonction Verification_Saisie Fonction permettant la vérification de la saisie utilisateur **********************************/ void cCalculatrice::Verification_Saisie() { //Nous définissons qu'il y a une erreur pour la première saisie avant vérification m_bErreur = true; //Boucle tant qu'il y a une erreur while(m_bErreur == true) { //Définissons qu'il n'y a pas de décimal de mise avant la vérification m_bDecimal = false; //Définissons les variables de positions int intPos = 0; //définissons une variable temporaire de travail string strTemp = m_strSaisie; //Boucle tant que la vérification de la chaine n'est pas finie while(intPos == 0 and strTemp != "") { if(m_bDecimal == false) { //Enregistre la position du caractère autorisé en cours intPos = strTemp.find_first_of("0123456789.+-*/"); if(strTemp.find_first_of(".") == 0) m_bDecimal = true; } else { if(strTemp.find_first_of("+-*/") == 0) { intPos = strTemp.find_first_of("0123456789.+-*/"); m_bDecimal = false; } else //Le programme n'accepte plus de décimal intPos = strTemp.find_first_of("0123456789+-*/"); } //Test si Le caractère est autorisé. if(intPos == 0) { m_bErreur = false; strTemp = strTemp.erase(0,1); } //sinon ne pas valider la saisie else { m_bErreur = true; break; } } //Si il y a une erreur, nous demandons de rentrez un nouveau nombre if(m_bErreur == true) { cout << "vous n'avez pas rentré un nombre correct" << endl; cout << "entrez un nombre correct" << endl; Saisie_Utilisateur(); } } } /********************************** Fonction Extraction Fonction permettant d'extraire les différentes partie de l'opération. **********************************/ void cCalculatrice::Extraction() { //Définissons la variables de positions int intPos = 1,i = 0; //Définissons une variable d'enregistrement temporaire string strTemp = ""; //définissons une variable temporaire de travail string strTempSaisie = m_strSaisie; //Boucle tant que l'extraction des nombres est incomplète while(intPos != 0) { //Enregistre la position de l'opérateur intPos= strTempSaisie.find_first_of("+-*/"); //Extraction des nombres if(intPos > 0) { strTemp= strTempSaisie.substr(0,intPos); //enregistrement des nombres valides après conversion std::istringstream Argument(strTemp); Argument >> m_dblNombre[i]; //enregistrement de l'opérateur m_strOperand[i]= strTempSaisie.substr(intPos,1); //Suppression des nombres validés strTempSaisie = strTempSaisie.erase(0,(intPos+1)); //incrémentation de la position des tableaux d'enregistrement i++; } else { //enregistrement des nombres valides après conversion std::istringstream Argument(strTempSaisie); Argument >> m_dblNombre[i]; break; } } } /********************************** Fonction Calcul Fonction de calcul de l'opération **********************************/ void cCalculatrice::Calcul() { //Initialisation de la variable de résultat m_dblResultat = m_dblNombre[0]; int i = 0; //Fonction de boucle tant que le compteur est inférieur au nombre d'opérandes de l'opération while(m_strOperand[i] != "") { //Fonction de test de l'opérande en cours et calcul le résultat en conséquence if(m_strOperand[i] == "+") m_dblResultat = m_dblResultat + m_dblNombre[i+1]; else if(m_strOperand[i] == "-") m_dblResultat = m_dblResultat - m_dblNombre[i+1]; else if(m_strOperand[i] == "*") m_dblResultat = m_dblResultat * m_dblNombre[i+1]; else if(m_strOperand[i] == "/") m_dblResultat = m_dblResultat / m_dblNombre[i+1]; i++; } } /********************************** Fonction Menu Fonction de Menu **********************************/ void cCalculatrice::Menu() { system("cls" ); cout << "saisir une operation tapez 1 ou quitter tapez 2" << endl; cin >> m_intMenu; }
C'est le même code que dans le tutoriel précédent. N'oubliez pas de vérifier les noms des variables et d'ajouter le code dans la fonction de vérification pour la décimal. Il ne reste plus qu'a voir le fichier main.cpp et main.h
Fichier main.h
/********************************** Program : calc2007 Fichier : main.h Créateur : bioopo Creation : 29/12/2006 logiciel : dev-c++ Version : 0.3b Modification : 31/12/2006 **********************************/ /********************************** Ce fichier déclare les fonctions et les variables globales utilisées dans le programme **********************************/ /********************************** Fichiers a inclure **********************************/ #include "ccalculatrice.h" /********************************** Définition des variables **********************************/ //Création de la calculatrice cCalculatrice calc;
Voila, nous définissons une instance de la classe cCcalculatrice, et nous supprimons toutes les variables et fonctions.
Fichier main.cpp
/********************************** Program : calc2007 Fichier : main.cpp Créateur : bioopo Creation : 25/12/2006 logiciel : dev-c++ Version : 0.4b Modification : 31/12/2006 **********************************/ /********************************** Ce programme est une calculatrice en console pour l'apprentissage des bases en c++ **********************************/ /********************************** Fichiers a inclure **********************************/ #include <cstdlib> #include <iostream> #include "ccalculatrice.h" #include "main.h" /********************************** Utilisation de l'espace de noms standard **********************************/ using namespace std; /********************************** Fonction main Fonction principale du programme **********************************/ int main(int argc, char *argv[]) { /********************************** Corps de la fonction **********************************/ calc.Initialisation(); }
Nous supprimons toutes les fonctions et le code de la fonction main, puis nous appelons la fonction d'initialisation de l'instance de classe calc. Ne pas oublier d'inclure le fichier ccalculatrice.h
Voilà, le développement est terminé.
Vous voyez, la calculatrice fonctionne de la même façon. Le seul bug qui reste est dans le choix du menu, si je tape une opération avec +2 à la fin il quitte le programme. Nous Réglerons ça plus tard, car ce n'est pas un problème grave.
Base vue dans ce tutoriel :
Nous avons vu dans ce tutoriel et les précédents :
Le nommage dans les classes en c++ :
Je finirais ce tutoriel en vous disant de bien assimiler la notion de classe, d'essayer de faire des petits programmes utilisant les connaissances acquises avant de vous lancer dans le tutoriel suivant. Les possibilités de programme sont déjà plus vastes que pour les tutoriels précédents.
En espérant que ce tutoriel ai pu vous aider et qu'il vous a plu. Bon courage pour la suite.
Merci a tous.