Bioopo@neuf.fr

Le 31/12/2006

Comment debuter en c++

I - Introduction

Nous allons commencer ce tutorial par un bug. Et oui, j'ai oublié de programmer la fonction qui vérifie les décimal, donc nous avions un bug quand un nombre avait plusieurs décimal. Nous le corrigerons dans ce tutorial.

La grande innovation et la seule chose que nous allons découvrir dans ce tutorial 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à ,ca 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

II - Connaissances requises

Les connaissances requises sont celles acquises au tutorial numero 1 à 3 : Débutez en c++. Il faut savoir :

• Definir une variable et son type. (char, int et double)

• Initialiser les variables

• faire un calcul de base en mathematique

• créer une fonction de test standard (if, if else if)

• Enregistrer une variable a partir d'une saisie au clavier (cin)

• Afficher a l'ecran un message ou une variable. (cout)

• inserer 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 a une fonction.

• Définir, déclarer et appeler variables et fonctions de la librairie standard string

• La conversion de variable string en double

III - Cahier des charges

1 - Le but du programme

Le but du programme est d'afficher le résultat d'une opération saisie par l'utilisateur.

2 - Les moyens misent 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'éxécutable de la calculatrice ne devra pas dépasser 500 Ko.

3 - Les mises à jour

Conception du programme à l'aide des classes. Changement de la structure du programme.

IV - Analyse fonctionnelle

Pour ce tutorial, nous ne devons rien modifier dans l'analyse fonctionnelle, mais seulement l'analyse structurelle de notre projet initial.

1 - Fonction FP0 : Calculatrice

V - Analyse structurelle

1 - 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) à des données communes à chaque modèles, sa vitesse, son poid, 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, avanceer, 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 difé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 ligne 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 gagné des milliers de ligne de code, de la simplicitée et un language orienté objet.

Au stade de notre programme, la création d'une classe pour la calculatrice peut parraitre inutile, et vous avez raison. Le programme fonctionne très bien, il est déjà simple et rajouter des fichiers ne sert pas à grand chose, mais vous êtes dans une série de tutorial, nous sommes la 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 tutorial, nous définirons une vrai structure orienté 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.

VI - 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 convention de nommage des classe 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 enregistrer 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 notres.

Fichier ccalculatrice.h

/**********************************

Program : calc2007

Fichier : ccalculatrice.h

Créateur : bioopo

Mail : bioopo@neuf.fr

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

Mail : bioopo@neuf.fr

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 calsse

**********************************/

cCalculatrice::cCalculatrice()

{

}

/**********************************

Destructeur de classe

**********************************/

cCalculatrice::~cCalculatrice()

{

}

Voila, regardons de plus prêt 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'éxécutable du programme.

Ensuite, il y a le constructeur de classe, cette fonction est particulière, elle est appeler a la création d'une instance de classe, pour créer celle-ci. Alors que le destructeur est appeler quand nous détruisons cette instance de classe.

Le mot clé public fait partie des mots clès définnisant la protection des méthodes (fonctions) et des membres (variables) de la classe. Ce mot signifie que les méthodes et les membres définies 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 tutorial précédant. 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();

/**********************************

Definition des variables

**********************************/

private:

//Variable contenant la saisie de l'operateur.

std::string m_strSaisie;

//variable contenant le signe de l'operation

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 presence d'erreur

bool m_bErreur;

//variable de presence de decimal

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 copier 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 seule les méthodes de la classe y auront accès. Pour les méthodes, c'est la même chose, a part que nous ne les renommons pas. Vous pouvez voir qu'une seule fonction est public, ce qui 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'aà partir de la classe. A quoi cela peut-il servir, est bien tous 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 calsse

**********************************/

......

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'operation à l'écran

cout << "Le resultat est" << endl;

cout << m_dblResultat << endl;

system("PAUSE");

Menu();

}

else

Menu();

}

if(m_intMenu == 2)

{

//Appel de la function 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 la l'extraction des nombres est incpomplè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);

//enregisrement des nombres valides après convertion

std::istringstream Argument(strTemp);

Argument >> m_dblNombre[i];

//enregisrement de l'opérateur

m_strOperand[i]= strTempSaisie.substr(intPos,1);

//Suppression des nombres validés

strTempSaisie = strTempSaisie.erase(0,(intPos+1));

//incrementation de la position des tableaux d'enregistrement

i++;

}

else

{

//enregisrement des nombres valides après convertion

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 resultat

m_dblResultat = m_dblNombre[0];

int i = 0;

//Fonction de boucle tant que le compteur est inferieur au nombre d'operands de l'operation

while(m_strOperand[i] != "")

{

//Fonction de test de l'operand en cours et calcul le resultat en consequence

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 tutorial précérent. 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

Mail : bioopo@neuf.fr

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"

/**********************************

Definition 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

Mail : bioopo@neuf.fr

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();

}

ous supprimons toutes les fonctions et le code de la fonction main, puis nous appelons l fonction d'initialisaion de l'insance de classe calc. Ne pas oubliez d'inclure le fichier ccalculatrice.h

voilà, le développement est terminé.

VII - 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 a la fin il quitte le programme. Nous Réglerons ça plus tard, car ce n'est pas un problème grave.

VIII - Récapitulatif

Base vu dans ce tutorial:

• Définir, déclarer et appeler une classe personnalisée

Nous avons vu dans ce tutorial 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

IX - 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 prefixe de type puis le nom.

• Une méthode ne prend pas de prefixes

X - Conclusion

Je finirais ce tutorial en vous disant de bien l'assimiler la notion de classe, d'essayer de faire des petits programmes utilisant les connaissances acquises avant de vous lancer dans le tutorial suivant. Les possibilités de programmes sont déjà plus vastes que pour les tutoriaux précédents.

En espérant que ce tutorial a pu vous aider et qu'il vous a plu. Bon courage pour la suite.

Bientôt le prochain tutorial.

Merci a tous.