CodeS-SourceS
Rechercher un code, un tuto, une réponse

Débutez en c++ n°4

Août 2017


Comment debuter en c++ n°4



Description


Ce tutoriel implante les classes personnalisés

Liens Vers les autres tutoriels de la série :


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ésDétails
Code d'identificationFP0
NomCalculatrice
ObjectifAfficher le résultat d'une opération saisie par l'utilisateur
Données fourniesAucune
Actions utilisateurSaisie de l'opération
Données sortiesRésultat de l'opération
Sous-fonctionsFP1 : Enregistrement saisie
FP2 : Calcul
FP3 : Affichage du résultat
FP4 : Vérification des saisies
FA1 : Menu
Description détailléeLa 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.

A voir également

Publié par bioopovega.
Ce document intitulé «  Débutez en c++ n°4  » issu de CodeS-SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.
Débutez en c++ n°3
Programmer et compiler le C/C++ sous Ubuntu