Débutez en c++ n°4
Comment debuter en c++ n°4
Description
Ce tutoriel implante les classes personnalisés
Liens Vers les autres tutoriels de la série :
- Débutez en C++
- Débutez en C++ n°2
- Débutez en C++ n°3
- [Débutez en C++ n°4]
Bioopo
Le 31/12/2006
Introduction
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 :
- Correction de la fonction de vérification pour vérifier les décimal
- La création l'initialisation et l'utilisation d'une classe personnalisée
Connaissances requises
Les connaissances requises sont celles acquises aux tutoriels numéros 1 à 3 : Débutez en c++. Il faut savoir :
- Définir une variable et son type. (char, int et double)
- Initialiser les variables
- Faire un calcul de base en mathématiques
- Créer une fonction de test standard (if, if else if)
- Enregistrer une variable a partir d'une saisie au clavier (cin)
- Afficher à l'écran un message ou une variable. (cout)
- Insérer des commentaires
- Définir, déclarer et appeler une fonction
- La portée des variables : globales et locales
- Définir et initialiser un tableau
- Les fonctions de boucle while et for
- La fonction de choix switch
- La conversion de chaine de caractère en double
- La création d'un fichier d'entête
- Le passage des arguments à une fonction.
- Définir, déclarer et appeler variables et fonctions de la librairie standard string
- La conversion de variable string en double
Cahier des charges
Le but du programme
Le but du programme est d'afficher le résultat d'une opération saisie par l'utilisateur.
Les moyens mis en oeuvre
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.
Les mises à jour
Conception du programme à l'aide des classes. Changement de la structure du programme.
Analyse fonctionnelle
Pour ce tutoriel, nous ne devons rien modifier dans l'analyse fonctionnelle, mais seulement l'analyse structurelle de notre projet initial.
Fonction FP0 : Calculatrice
| 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. |
Analyse structurelle
Les classes
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.
Développement
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é.
Post-développement
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.
Récapitulatif
Base vue dans ce tutoriel :
- Définir, déclarer et appeler une classe personnalisée
Nous avons vu dans ce tutoriel et les précédents :
- Les types de variables : int, double, char, bool, string
- Les fonctions : if, if elseif else, switch, for, while, cin, cout.
- Les fonctions personnalisées de type void.
- Les tableaux de type char et double.
- La création de fichier header.
- Des fonctions de la librairie standard string : find_first_of, erase, substr
- Les classes personnalisées
Complément
Le nommage dans les classes en c++ :
- Un nom de classe commence par la lettre c.
- Un nom de membres (variables) comment par m_ puis le préfixe de type puis le nom.
- Une méthode ne prend pas de préfixe
Conclusion
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.
- Débutez en c++ n°4
- Errordomain=nscocoaerrordomain&errormessage=impossible de trouver le raccourci spécifié.&errorcode=4 - Forum C# / .NET
- Exception asp.net - Forum ASP.NET
- Problème avec web config - Forum ASP.NET
- Création d'un raccourci - Forum C# / .NET
- 4 derniers caractères de l'iban - Forum Visual Basic