Bioopo
Bioopo@neuf.fr
Le 28/12/2006
Comment debuter en c++
I - Introduction
Bienvenue dans mon tutorial concernant l'apprentissage de base du c++. Son apprentissage est un long chemin où découragement, blocages et agacement font partie du quotidien, mais la joie ressentie lors d'un challenge réussi ( je ne parle pas d'un programme , mais de l'avancement de l'apprentissage dans la douleur) est bien plus grande que si l'on fait la même chose dans un langage plus facile et compréhensible.Voilà comment je vois l'apprentissage du c++, il faut être motivé, prendre son temps et ne pas avoir peur des échecs. Une fois que vous avez compris cela, vous pouvez vous lancer dans l'apprentissage du langage.
Ce tutorial n'est pas une bible ni un cours magistral du c++, il faut le prendre pour ce qu'il est, ma vision de l'apprentissage de ce beau langage.Il n'expliquera pas tout, ce n'est pas son rôle, il faudra faire des recherches par vous même, internet regorge de données sur le code du c++. Il vous montrera une méthodologie personnelle de pré-conception, de conception ,de développement et de post-développement. Ce tutorial est conçu avec un exemple unique, une calculatrice basique, qui permet de se concentrer sur l'essentiel sans se préoccuper du superflu ( puisqu'il n'y en a pas) .
Je vais vous expliquer comment est construit ce tutorial, Il y a dix grandes parties :
| Titre | Description |
| Introduction | Introduction des grandes lignes du toturial plus mes idées. |
| Connaissances requises | Connaissances que vous devez avoir pour réaliser le tutorial. |
| Cahier des charges | Définition des points importants du projet. |
| Analyse fonctionnelle | Analyse de chaques fonctions du projet. |
| Analyse structurelle | Analyse les structures par rapport aux fonctions |
| Développement | Ecriture du code. |
| Post-développement | Détection et correction d'erreurs, rapport de fonctions manquantes. |
| Récapitulatif | Récapitulation des connaissances acquises depuis le début. |
| Complément | Documentation annexe. |
| Conclusion | La conclusion du projet. |
Le tutorial contiendra plusieur types d'informations, avec un format spécifique à chaque type.
Les éléments normaux.
Les remarques importantes.
Pour le code c'est un peu plus compliqué:
Nom du fichier - Nom de la fonction.
......
code déjà écrit
code à écrire
......
Un petit mot sur le projet, la calculatrice que nous allons créer à travers les tutoriaux sera une calculatrice en mode console, avec les opérations standards. Elle sera capable d'effectuer les additions, soustractions , multiplications, divisions ....ainsi que plusieurs opérations avancées que nous détaillerons dans un autre tutorial. Car d'abord, il faut apprendre les bases et le supperflu peut vite devenir génant.
II - Connaissances requises
Il n'y a pas de besoin d'avoir des connaissances en c++ pour ce tutorial, car c'est un tutorial pour les personnes souhaitant débuter avec ce langage.
III - Cahier des charges
N'étant pas un grand spécialiste en ce qui concerne la rédaction d'un cahier des charges, je me contente du minimum, son but étant de définir avec précision le but du programmes et les moyens mise en oeuvre.
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.
IV - Analyse fonctionnelle
L'analyse fonctionnelle sert à déterminer les différentes fonctions du programme, je parle des différentes portions qui, mis en inter-connexion parviendront à éxécuter le programme.
Il n'y a pas de code, pas de langage c++, mais simplement du français, le but de l'analyse fonctionnelle étant de découper les différentes actions à entreprendre et de les connecter.
La notation des fonctions dans l'analyse fonctionelle, il y a les fonctions principales, les fonctions secondaires et les fonctions annexes. Les fonctions principales, notées Fpx (x étant le numéro de la fonction, correspond au grandes lignes du programme. Les fonctions secondaires découpent les fonctions principales en plus actions localisées, elle sont notées Fsx.y (x étant le numéro de la fonction principale à laquelle elles se rapportent, y étant le numéro de la fonction secondaire). Les fonctions annexes sont des fonctions non-nécessaire au fonctionnement du programme, mais qui peuvent apporter des petits plus.Elles sont notées Faz (z étant le numéro de la fonction annexe).
Une fonction principale spécifique est la fonction FP0. C'est en faites la racine de l'analyse fonctionnelle, elle regroupe toutes les autres fonctions principales et les fonctions annexes.
Une analyse de fonction, qu'elle soit principale, secondaire ou annexe, contient toujours huit spécificités:
-
La première étant un code d'identification (voir paragraphe ci-dessus).
-
La seconde étant l'objectif de la fonction.
-
La troisième, les données que nous lui fournissons.
-
La quatrième, les actions utilisateurs.
-
La cinquième, les données en sortie.
-
La sixième, une explication détaillée du fonctionnement pour arriver à son objectif.
-
La septième, une liste des sous fonctions associés(si il y en a besoin).
-
La huitième étant son nom.
Il existe plusieurs méthodes pour faire une analyse fonctionnelle, nous en verrons deux. Pour les petits programmes comme celui-ci, nous utiliserons des tableaux pour définir les fonctions. Pour des projets plus gros, nous utiliserons des diagrammes, nous les utiliserons quand la calculatrice commencera a avoir plus de fonctionnalités.
Nous pouvons commencer notre analyse fonctionnelle. La première étape consiste a définir la fonction FP0.
1 - 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 fournis | 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 |
| 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. |
2 - Fonction FP1 : Enregistrement saisie
| Spécificités | Détails |
| Code d'identification | FP1 |
| Nom | Enregistrement saisie |
| Objectif | Enregistrer les saisies utilisateur |
| Données fournis | Aucune |
| Actions utilisateur | Saisie de l'opération |
| Données sorties | Saisie enregistrée |
| Sous-fonctions | Aucune |
| Description détaillée | La Fonction devra enregistrer la saisie utilisateur. |
3 - Fonction FP2 : Calcul
| Spécificités | Détails |
| Code d'identification | FP2 |
| Nom | Calcul |
| Objectif | Effectuer le calcul de l'opération saisie par l'utilisateur |
| Données fournis | Saisie enregistrée |
| Actions utilisateur | Aucune |
| Données sorties | Résultat du calcul |
| Sous-fonctions | Aucune |
| Description détaillée | La Fonction devra choisir quel est le calcul a effectuer en fonction de la saisie de l'utilisateur. |
3 - Fonction FP3 : Affichage du résultat
| Spécificités | Détails |
| Code d'identification | FP3 |
| Nom | Affichage du résultat |
| Objectif | Afficher le résultat de l'opération |
| Données fournis | Résultat du calcul |
| Actions utilisateur | Aucune |
| Données sorties | Résultat affiché |
| Sous-fonctions | Aucune |
| Description détaillée | La Fonction devra afficher le résultat de l'opération saisie |
Voila, notre analyse fonctionnelle est terminée, bien sur, vous pouvez trouver ça barbant de réécrire plusieurs fois les mêmes choses et faire tout ça pour un petit programme, mais habituez vous à le faire, car dans les plus gros projet, comme notre calculatrice en version 1, il sera bon d'avoir finit les fondations avant de programmer.
Attention, je vous déconseille, en plein milieu du programme de vouloir ajouter d'autres fonctions, il vaut mieux les noter sur un bout de papier, finir correctement votre projet, et ensuite, effectuer une nouvelle version de votre programme. Sinon, vous risquez de vous embrouiller et de faire des erreurs que vous mettrez un temps fou à réparer.
V - Analyse structurelle
L'analyse structurelle sert à déterminer les structures nécessaires au projet. Il n'est pas question de créer le code entier maintenant, c'est le rôle de la phase de développement. Mais plutôt de collecter les différentes fonctions et variables nécessaires pour éxécuter correctement cette fonction. Il s'agit ici de raisonnement logique et de français. C'est dans cette analyse que ce fera le plus gros de la recherche des fonctions du language.Nous reprendrons partiellement les tableaux de l'analyse fonctionnelle, car c'est de cette base que nous partirons pour faire cette analyse.
1 - Fonction FP1 : Enregistrement saisie
| Spécificités | Détails |
| Code d'identification | FP1 |
| Nom | Enregistrement saisie |
| Objectif | Enregistrer les saisies utilisateur |
| Actions utilisateur | Saisie de l'opération |
| Données sorties | Saisie enregistrée |
| Description détaillée | La Fonction devra enregistrer la saisie utilisateur. |
Il y a deux actions a réaliser, la première étant la saisie de l'utilisateur au clavier, la seconde étant d'enregistrer cette saisie. En c++, il existe des fonctions de bases qui nous permettent d'éxécuter ces deux actions.
La première est la fonction cin, qui permet de demander à l'utilisateur d'entrée des données au clavier.
La seconde, est une variable, elle permet de stoquer en mémoire une données.
2 - Les variables
Les variables sont des zones mémoires ou nous pouvons stoquer des données, des nombres, des lettres ou d'autres types de données. Pour permettre d'allouer une zone mémoire, il faut que le programme connaisse la taille de la variable (il y a des execptions que nous verront plus tard). Pour cela, il faut définir le type de la variable, il en existe des standards et des personnalisées, pour le moment, nous verrons les standards.
Pour stoquer des nombres, il y a plusieurs types :
-
int, pour les nombres entiers ( 1 2 3 .....)
-
float, pour les nombres à virgule (1,23 2,5 ....)
-
double
-
long
Pour stoquer les caractères comme les lettres ou les caractères spéciaux ( + - ; $ ), il y a un seul type de base :
pour pouvoir utiliser ces variables, il faut les définir et les initialiser car la zone allouée peut contenir des données anciennes et créer des erreurs dans votre programme.
type_de_la_variable Nom_de_la_variable;
Nom_de_la_variable = valeur;
type_de_la_variable Nom_de_la_variable= valeur;
exemple :
int intNumeroRue = 0;
Cela signifie que nous avons alloués une zone mémoire que le programme connait sous le nom intNombre et que nous lui avons donnés comme valeur 0.
Il existe un principe dans le nommage des variable, il s'agit de mettre un préfixe a la variable indiquant le type de cette variable, et de mettre un nom définissant bien le rôle de la variable. Cela rend le code plus lisible sans avoir a chercher le type et le rôle de la variable quand il sagit d'un long programme. Prenez l'habitude de cette écriture.
3 - La fonction de base cin
La fonction cin est une fonction de base du c++, elle permet à l'utilisateur de saisir des données au clavier, puis de l'enregistrer dans une variable. Elle s'utilise comme ceci :
cin >> Nom_De_Variable;
Récapitulatif des variables et fonctions de FP1
| Variables et fonctions | Type | Détails |
| intNombre1 | int | Enregistre le premier nombre saisi |
| intNombre2 | int | Enregistre le second nombre saisi |
| chrOperand | char | Enregistre le signe de l'opération |
| cin |
| Demande la saisie et l'enregistre |
L'analyse de cette fonction est terminée. Nous pouvons passer à la fonction FP2.
4 - Fonction FP2 : Calcul
| Spécificités | Détails |
| Code d'identification | FP2 |
| Nom | Calcul |
| Objectif | Effectuer le calcul de l'opération saisie par l'utilisateur |
| Données fournis | Saisie enregistrée |
| Données sorties | Résultat du calcul |
| Description détaillée | La Fonction devra choisir quel est le calcul a effectuer en fonction de la saisie de l'utilisateur. |
La fonction de calcul est la plus compliquée des trois, normal puisque c'est la que le programme fait 99% des taches. Il y a deux actions à réaliser, la première étant de faire le choix de l'opération en fonction du signe de l'opération, la seconde étant de calculer l'opération.
Il existe plusieurs fonctions standard pour faire un choix en c++, pour commencer, nous en verrons une, la fonction de test if.
5 - La fonction de test if
Elle peut se traduire par : si la condition est remplie, alors on execute le code. Elle s'utilise comme cela :
if(condition)
{
code a executer;
}
Nous pouvons faire plusieurs tests en une seule fois avec la fonction if ... else if. Elle se traduit par
si la condition est remplie, alors on execute le code, sinon si la seconde condition est remplie alors on execute son code. Elle s'utilise comme cela :
if(condition)
{
code a executer;
}
else if(condition2)
{
code a executer;
}
6 - Les opérations mathématiques
La seconde condition à éxécuter est une simple opération mathématique, pour la réaliser, nous écrivons pour une addition par exemple :
Nom_Variable = Nom_Variable1 + Nom_Variable2
Récapitulatif des variables et fonctions de FP2
| Variables et fonctions | Type | Détails |
| intNombre1 | int | Enregistre le premier nombre saisi |
| intNombre2 | int | Enregistre le second nombre saisi |
| chrOperand | char | Enregistre le signe de l'opération |
| intResultat | int | Enregistre le résultat de l'opération |
| If |
| Choisi l'opération à effectuer |
L'analyse de cette fonction est terminée. Nous pouvons passer à la fonction FP3.
7 - Fonction FP3 : Affichage du résultat
| Spécificités | Détails |
| Code d'identification | FP3 |
| Nom | Affichage du résultat |
| Objectif | Afficher le résultat de l'opération |
| Données fournis | Résultat du calcul |
| Données sorties | Résultat affiché |
| Description détaillée | La Fonction devra afficher le résultat de l'opération saisie |
Il n'y a qu'une seule action dans cette fonction, afficher le résultat obtenu par la fonction de calcul. Pour cela, nous utiliseront la fonction standard d'affichage à l'écran, cout.
8 - La fonction de base cout
La fonction cout est une fonction de base du c++, elle permet d'afficher des données à l'écran. Elle s'utilise comme ceci :
cout << Nom_De_Variable;
Récapitulatif des variables et fonctions de FP3
| Variables et fonctions | Type | Détails |
| intResultat | int | Enregistre le résultat de l'opération |
| cout |
| Affiche des données à l'écran |
VI - Développement
1 - Le fichier main.cpp
Voila, il est temps de lancer le logiciel dev-c++. Dans le menu Fichier, cliquer sur nouveau projet, sélectionnez console application puis nommer votre projet et choisissez projet c++, enfin cliquez sur ok. Ensuite choisissez le répertoire où le sauvegarder et le nom du fichier de projet. Un fichier main.cpp est alors créé, sauvegardez le sous le même nom.
Avant de nous lancer dans le développement de notre projet, regardons de plus prêt ce qu'il contient.Les première lignes sont :
#include <cstdlib>
#include <iostream>
La fonction #include permet d'inclure les librairies (ce sont des fichiers contenant des fonctions) qui nous servirons pour notre programme. Elles permettent d'utiliser des fonctions sans avoir a écrire leur code, il y a les librairies standard du c++ et les librairies personnalisées). Les librairies standard contiennent les fonction standard du c++, comme les fonctions d'entrées sorties, mathémathiques ....
Nous ne verrons pas dans ce chapitre les librairies personnalisées, mais ce sont des fichiers écrit par des programmeurs qui les donnent ou des librairies spécialement conçu pour un programme spécifique par le programmeur.
La librairies <iostream> est une librairie standard qui a des fonctions gérant les entrées / sorties. Sans ces lignes, vous ne pourriez pas utiliser les fonctions standard du c++. De plus, il existe d'autres librairies standard, que vous devrez inclure avant de pouvoir utiliser des fonctions spécifiques.
Passons a la seconde ligne:
using namespace std;
Cette ligne définit l'espace de nom standard.
Ce qui signifie que les librairies standard utiliseront cet espace de nom. Il est nécessaire pour la suite. Passons a la fin du code :
int main(int argc, char *argv[])
{
system("PAUSE");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) est une fonction. Elle est définit comme suit :
le type de retour de la fonction : int
le nom de la fonction : main
Les arguments a passer a la fonction : (int argc, char *argv[])
Ces arguments peuvent être des variables, des chaines de caractères ou des nombres.
Quand il s'agit de variables comme ici, nous définissons la variable avec son type et son nom.
Les accolades : { }
c'est ici que l'on écrit le code de la fonction. La fonction débute a l'accolade d'ouverture et finit a l'accolade de fin. Selon le type de retour de la fonction, elle devra retourner une valeur.
La fonction system("PAUSE"); attend que l'on press une touche pour arreter le programme.
La fonction return EXIT_SUCCESS; retourne au programme la valeur permettant de quitter le programme.
La fonction main est nécessaire, c'est la que commence le programme. Nous commencerons dans cette version a coder a l'interieur même de la fonction pour ensuite, dans le prochain tutorial examiner la notion de fonction.
Une des choses importantes à faire dans cette phase de programmation est de commenter notre code afin qu'il soit plus lisible par d'autres personnes et pour nous, dans les phases de recherches d'erreurs(Une des parties les plus importantes de la programmation).
Il existe en c++, deux façons de mettre des commentaires, la première est un commentaire sur une seul ligne, nous utilisons pour cela deux barres obliques pour définir que la ligne est une ligne de commentaire.
//ceci est un commmentaire
ceci n'est pas un commentaire
Il y a aussi une deuxième façon, c'est de créer un bloc de commentaire qui peut être sur plusieurs ligne, nous utilisons une barre oblique suivi d'un asterisque, que nous terminons par un asterisque suivi d'une barre oblique.
/* ceci est un bloc de commentaire */
/*ceci est un
bloc de commentaire*/
/* ceci n'est pas un bon car nous n'avons pas fermer le bloc, le programme fermera le bloc a la prochaine fin de bloc.
Pour ma part, je met un entete au début de chaque fichier de mon programme. Pour notre calculatrice par exemple :
/**************************************
programme : Bioopo-vega calc 2007
Fichier : calc.cpp
Créateur : bioopo
Mail : bioopo@neuf.fr
Creation : 25/12/2006
**********************************/
ainsi qu'une breve description du projet :
/**********************************
Ce programme est une calculatrice
en console pour l'apprentissage des
bases en c++
**********************************/
ensuite je définit des zones pour chaque parties différentes du programmes :
Fichiers a inclure
Nom de fonction avec sa description
Initialisation des varaiables
Code principal de la fonctions ........
Apprendre a bien utiliser les commentaires peut vous éviter de longues nuits d'acharnement pour retrouver une erreurs.
N'oubliez pas : Beaucoup d'informations vallent mieux que pas assez, mais trop d'informations (qui ne servent a rien ) tuent l'information.De plus, ne mettez pas de commentaires général, par exemple
//variable de type double
double dblNum;
Ce commentaire ne sert a rien, il faut indiquez plus d'information :
//variable contenant le premier nombre saisie
double dblNum;
si vous notez correctement le nom des variables, il est inutile dans le commentaire d'inscrire le type de cette variable. De plus, il vaut mieux mettre un nom plus significatif a la variable :
//variable contenant le premier nombre saisie
double dblSaisie1;
voila un commentaire correct qui explique le but de cette variable ainsi qu'un nom de variable correct qui définit en lui même son type et son but.
Voila je pense que nous pouvons passez au code maintenant.
2 - Les commentaires
Nous allons donc commencer par la fonction FP1, mais juste avant nous allons ajouter les commentaires au fichier.
Fichier main.cpp
/**********************************
Program : calc2007
Fichier : main.cpp
Créateur : bioopo
Mail : bioopo@neuf.fr
Creation : 25/12/2006
logiciel : dev-c++
Version : 0.1a
Modification : 26/12/2006
**********************************/
/**********************************
Ce programme est une calculatrice
en console pour l'apprentissage des
bases en c++
**********************************/
/**********************************
Fichiers a inclure
**********************************/
#include <cstdlib>
#include <iostream>
/**********************************
Utilisation de l'espace de noms standard
**********************************/
using namespace std;
/**********************************
fonction main
fonction principale du programme
**********************************/
int main(int argc, char *argv[])
{
/**********************************
Definition et initialisation des variables
**********************************/
/**********************************
Corps de la fonction
**********************************/
//Appel de la function demandant une pause et de presser une touche pour quitter.
system("PAUSE");
return EXIT_SUCCESS;
}
Bien entendu ne pas écrire les pointillés si il y en a , ils ne sont la que pour dire ce qu'il y a après ou avant le code quand je ne mettrez que la partie qui nous interresse,ici, je met les commentaires de début de programmation donc tout le fichiers est écrit, il ne vous reste plus qu'a écrire les parties en gras italique.
Nous allons définir et initialiser les variables.
3 - Définition des variables
Fichier main.cpp - fonction main
........
/**********************************
Definition et initialisation des variables
**********************************/
//variable contenant les nombres saisies
int intNombre1 = 0, intNombre2 = 0;
//variable contenant le résultat de l'operation
int intResultat =0;
//variable contenant le signe de l'operation
char chrOperand = '0';
......
Nous voyons que nous pouvons itinialisez plusieurs variables du même type en mettant le suivant après une virgule. Je conseille toutefois de réunir seulement les variables qui correspondent a une même famille, par exemple je n'est pas mis la variable de résultat avec les variables de saisies, pourtant elles sont du même type, il faut tout faire pour que noter code soit lisible et simple a comprendre. De plus, je vous invite a espacer votre code, les lignes d'espace allègeront votre code et ne le rendront pas plus gros en terme de poid. Passons maintenant a la fonction FP1. Nous demandons a l'utilisateur de saisir un nombre, puis nous l'enregistrons (voir analyse fonctionnelle et structurelle):
4 - Fonction FP1 : Enregistrement saisie
Fichier main.cpp - fonction main
........
/**********************************
Corps de la fonction
**********************************/
//Fonction permettant a l'utilisateur de saisir le premier nombre
cin >> intNombre1;
//Fonction permettant a l'utilisateur de saisir le signe de l'operation
cin >> chrOperand;
//Fonction permettant a l'utilisateur de saisir le second nombre
cin >> intNombre2;
......
Vous voyez qu'une fois l'analyse fonctionnelle et structurelle faites en amont, la phase de programmation ne se résume qu'a ecrire le code, sans se soucier de comment on doit s'y prendre et quelle fonction utiliser. C'est pour cela que les premières phases de la conception sont très importantes.
Voila ceci fait, nous pouvons passez a la fonction FP2.
5 - Fonction FP2 : Calcul
Fichier main.cpp - fonction main
//Fonction permettant a l'utilisateur de saisir le second nombre
cin >> intNombre2;
........
//Test pour déterminer le signe de l'operation et calcul l'operation
if(chrOperand == '+')
{
intResultat = intNombre1 + intNombre2;
}
else if(chrOperand == '-')
{
intResultat = intNombre1 - intNombre2;
}
else if(chrOperand == '*')
{
intResultat = intNombre1 * intNombre2;
}
else if(chrOperand == '/')
{
intResultat = intNombre1 / intNombre2;
}
......
Nous avons vu la fonction de test if lors de la phase d'analyse structurelle, Les signes a l'interieur du test sont en guillement simple, ils donnent alors leur numéro de caracteres plutot que le caractere lui même. Le double égal est nécessaire, car c'est un operateur de comparaison, la ligne signifie :
si chrOperand vaut '+' alors éxecutont le code.
Si nous avions mis un signe égal simple cela nous aurez fait une erreur car il aurait affecté comme valeur a chrOperand le signe +. C'est très important de faire attention. De plus, pour la lisibilité du code, quand nous avons un test ou une boucle nous mettons le code de celle ci en retrait.
Nous avons donc notre fonction FP2, il ne reste plus qu'a coder la fonction FP3.
6 - Fonction FP3 : Affichage du résultat
Fichier main.cpp - fonction main
if(chrOperand == '/')
{
intResultat = intNombre1 / intNombre2;
}
......
//Fonction affichant le résultat de l'operation à l'écran
cout << intResultat;
......
Nous avons vu la fonction cout dans la phase de conception, nous ne reviendrons pas dessus.
Nous avons fini la partie programmation nous allons donc tester notre programme. Faites F9, le programme va compilez et s'éxecuter.
Saisissez 10 et faites entrée.
Saisissez + et faites entrée.
Saisissez 2 et faites entrée.
Le résultat de l'operation s'affiche et normalement il est juste
Maintenant, vous devez vous rendre compte que même si le but fixé est atteint, ce n'est pas beau ni très facile a comprendre le fonctionnement.C'est pour cela que nous avons une phase de post-développement.
VII - Post-développement
Cette phase est une des plus importante, elle vous permet de tester et de corriger les bugs et les lacunes de votre programme. Nous verrons la gestion des erreurs dans la seconde partie, pour le moment nous allons voir comment rendre ce programme plus conviviale.
La première des choses qui frappent quand on utilise le programme, c'est le manque d'informations pour l'utilisateur, nous savons quoi faire puisque c'est notre programme, mais il faut penser que dans 6 mois, nous ne nous en souviendrons plus, et si quelqu'un dautre le lance, il aura une page vide et ne sera pas quoi faire.
Il faut donc diriger l'utilisateur sur la fonction du programme et sur ce qu'il doit faire.
Fichier main.cpp - Fonction main
........
/**********************************
Corps de la fonction
**********************************/
//Fonction permettant a l'utilisateur de saisir le premier nombre
cout << "Bioopo-vega calculatrice 2007 version 0.1a" << endl;
cout << "Entrez le premier nombre" << endl;
cin >> intNombre1;
//Fonction permettant a l'utilisateur de saisir le signe de l'operation
cout << "Entrez le signe de l'operation + - * /" << endl;
cin >> chrOperand;
//Fonction permettant a l'utilisateur de saisir le second nombre
cout << "Entrez le second nombre" << endl;
cin >> intNombre2;
......
Fichier main.cpp - Fonction main
......
//Fonction affichant le résultat de l'operation à l'écran
cout << "Le résultat est" << endl;
cout << intResultat << endl;
......
C'est mieux comme ca, il reste cepandant quelques bugs.
Si nous mettons un nombre a virgule, le programme ne fais pas ce qu'on lui demande.
Si nous mettons un autre caractères que les signes + - * / pour le signe de l'operation le programme fait ne fais pas ce qu'on lui demande.
Le premier bugs est plus que facheux et le pire des deux.
Le deuxième est moins facheux mais plus long a rétablir.
Nous nous occupons donc des problèmes les plus facheux au moins facheux.
Pour le premier bugs, c'est tres simple, il nous suffit de changer le type de variable de int en double ou float pour le corriger.
Donc :
Fichier main.cpp - Fonction main
........
/**********************************
Definition et initialisation des variables
**********************************/
//variable contenant les nombres saisies
double dblNombre1 = 0.0, dblNombre2 = 0.0;
//variable contenant le résultat de l'operation
double dblResultat =0.0;
//variable contenant le signe de l'operation
char chrOperand = NULL;
......
N'oubliez pas de changer le prefixe de la variable dans tout le code, ni de changer l'initialisation en 0.0 car c'est comme cela que l'on pas un nombre a une variable de type double ( 1 devient 1.0 ...). Notre bug est réparé, Bien entendu, si c'était un vrai projet, nous aurions définit les variables en type double au moment de la conception. C'était seulement un exemple pour vous montrer la phase de post-développement et un type d'erreurs bête.
Une simple boucle de test de la saisie corrigera le second bug, mais nous verrons ceci dans le prochain tutorial.
VIII - Récapitulatif
Nous avons vu pas mal de base du c++ dans ce chapitre, apprenez a les maitrisez avant de continuer, faites des petits programmes test, recherchez dans des livres ou sur internet des informations concernant les différents types de variables. Une fois tout cela assimilez passez au prochain tutorial.
Base vu dans ce tutorial:
-
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)
-
Une nomenclature pour les variables
-
inserer des commentaires
-
Une méthode pour bien concevoir son projet.
IX - Complément
1 - Notation des version
Je note les versions comme suit: x,ya
x numero de version principale : quand la calculatrice aura les fonctions que nous voudront implémenter et sans bugs, il passera a 1
y numero de fonctionnalité : quand nous ajouterons des fonctionnalité a la calculatrice, ce numero augmentera. Pour le moment il est a 1 puisque nous implémentons les premières fonctionnalités.
a lettre de développement: elle peut prendre 2 positions, a : en développement et b bugs corrigés.
Notre version est donc la 0.1a car la calculatrice en est a son premier stade de développement, elle n'a que les fonctionnalités d'opérations de base et il reste des bugs.
X - Conclusion
Je finirais ce tutorial en vous disant de bien l'assimiler, d'essayer de faire des petits programmes utilisant les connaissances acquises avant de vous lancer dans le tutorial suivant. Je sais que ça limite les possibilités de programmes, mais c'est important d'assimiler ces bases avant de continuer. Le c++ n'est pas un langage que l'on apprend en deux jours.
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.