Débutez en c++
Débutez en c++
Description
Ce tutoriel sert à débuter en c++, en abordant les premières bases du c++ avec un exemple concret, la conception d'une calculatrice.
Celui-ci est le premier de la série.
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 28/12/2006
Introduction
Bienvenue dans mon tutoriel concernant l'apprentissage de base du c++. Son apprentissage est un long chemin où découragements, blocages et agacements 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 tutoriel 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 tutoriel 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).
Un petit mot sur le projet, la calculatrice que nous allons créer à travers les tutoriels 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 tutoriel. D'abord, il nous faut apprendre les bases et le superflu peut vite devenir gênant.
Connaissances requises
Il n'y a pas de besoin d'avoir des connaissances en c++ pour ce tutoriel, car il est destiné aux personnes souhaitant débuter avec ce langage.
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 programme et les moyens mis en oeuvre.
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.
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 à exé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 est de découper les différentes actions à entreprendre et de les connecter.
La notation des fonctions dans l'analyse fonctionnelle, 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, correspondent aux grandes lignes du programme. Les fonctions secondaires découpent les fonctions principales en plusieurs 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 fait 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ées (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 à avoir plus de fonctionnalités.
Nous pouvons commencer notre analyse fonctionnelle. La première étape consiste a définir la fonction FP0.
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 |
| 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. |
Fonction FP1 : Enregistrement saisie
| Spécificités | Détails |
|---|---|
| Code d'identification | FP1 |
| Nom | Enregistrement saisie |
| Objectif | Enregistrer les saisies utilisateur |
| Données fournies | 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. |
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 fournies | 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. |
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 fournies | 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. |
Voilà. 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. Habituez vous à le faire, car dans les plus gros projets, 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.
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. Nous devons plutôt collecter les différentes fonctions et variables nécessaires pour exécuter correctement cette fonction. Il s'agit ici de raisonnement logique et de français. C'est dans cette analyse que se fera le plus gros de la recherche des fonctions du langage. Nous reprendrons partiellement les tableaux de l'analyse fonctionnelle, car c'est de cette base que nous partirons pour faire cette analyse.
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 est la saisie de l'utilisateur au clavier, la seconde l'enregistrement de cette saisie. En c++, il existe des fonctions de bases qui nous permettent d'exécuter ces deux actions.
La première est la fonction cin, qui permet de demander à l'utilisateur d'entrer des données au clavier.
La seconde, est une variable, elle permet de stocker en mémoire une données.
Les variables
Les variables sont des zones mémoires ou nous pouvons stocker 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 exceptions 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 stocker 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 stocker les caractères comme les lettres ou les caractères spéciaux ( + - ; $ ), il y a un seul type de base :
char, contient 1 caractère.
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.
Pour Définir une variable :
type_de_la_variable Nom_de_la_variable;
Pour initialiser une variable : (lui attribuer une valeur)
Nom_de_la_variable = valeur;
Pour Définir et initialiser la variable en même temps :
type_de_la_variable Nom_de_la_variable = valeur;
Exemple :
int intNumeroRue = 0;
Cela signifie que nous avons alloué une zone mémoire que le programme connait sous le nom intNumeroRue et que nous lui avons donné comme valeur 0.
Il existe un principe dans le nommage des variables. Il s'agit de mettre un préfixe a la variable indiquant son type, et de mettre un nom définissant bien le rôle de la variable. Cela rend le code plus lisible, sans avoir à chercher le type et le rôle de la variable, quand il s'agit d'un long programme. Prenez l'habitude de cette écriture.
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
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 fournies | 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. C'est normal puisque c'est la que le programme fait 99% des taches.
Il y a deux actions à réaliser. La première est 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.
La fonction de test if
Elle peut se traduire par : si la condition est remplie, alors on exécute le code.
Elle s'utilise comme cela :
if(condition)
{
code a exécuter;
}
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 exécute le code, sinon si la seconde condition est remplie alors on exécute son code.
Elle s'utilise comme cela :
if(condition)
{
code a exécuter;
}
else if(condition2)
{
code a exécuter;
}
Les opérations mathématiques
La seconde condition à exé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
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 fournies | 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 utiliserons la fonction standard d'affichage à l'écran, cout.
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. |
Développement
Le fichier main.cpp
Voilà, il est temps de lancer le logiciel dev-c++. Dans le menu Fichier, cliquez sur nouveau projet, sélectionnez console application puis nommez 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ès ce qu'il contient. Les premières 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ématiques...
Nous ne verrons pas dans ce chapitre les librairies personnalisées. Ce sont des fichiers écrits par des programmeurs qui les donnent ou des librairies spécialement conçues pour un programme spécifique par le programmeur.
La librairie <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 à 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 à passer à 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 à l'accolade d'ouverture et finit à 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 presse une touche pour arrêter 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 là que commence le programme. Nous commencerons dans cette version à coder à l'intérieur même de la fonction pour ensuite, dans le prochain tutoriel 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 commentaire ceci n'est pas un commentaire
La 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 astérisque, que nous terminons par un astérisque 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 fermé le bloc, le programme fermera le bloc à la prochaine fin de bloc.
Pour ma part, je met un entête 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 Creation : 25/12/2006 **********************************/
ainsi qu'une brève description du projet :
/********************************** Ce programme est une calculatrice en console pour l'apprentissage des bases en c++ **********************************/
Ensuite, je définis des zones pour chaque partie différente du programme :
- Fichiers à inclure
- Nom de fonction avec sa description
- Initialisation des variables
- Code principal de la fonction
Apprendre à bien utiliser les commentaires, peut vous éviter de longues nuits d'acharnement pour retrouver une erreur.
N'oubliez pas : beaucoup d'informations valent mieux que pas assez, mais trop d'informations (qui ne servent a rien ) tuent l'information. De plus, ne mettez pas de commentaire général, par exemple :
//variable de type double double dblNum;
Ce commentaire ne sert a rien, il faut indiquer plus d'information :
//variable contenant le premier nombre saisi 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 significatif à la variable :
//variable contenant le premier nombre saisie double dblSaisie1;
Voilà un commentaire correct. Il 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.
Voilà. Je pense que nous pouvons passer au code maintenant.
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
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[])
{
/**********************************
Définition et initialisation des variables
**********************************/
/**********************************
Corps de la fonction
**********************************/
//Appel de la fonction demandant une pause et de presser une touche pour quitter.
system("PAUSE");
return EXIT_SUCCESS;
}
Nous allons définir et initialiser les variables.
Définition des variables
Fichier main.cpp - fonction main :
/********************************** Définition et initialisation des variables **********************************/ //variable contenant les nombres saisies int intNombre1 = 0, intNombre2 = 0; //variable contenant le résultat de l'opération int intResultat =0; //variable contenant le signe de l'opération char chrOperand = '0';
Nous voyons que nous pouvons initialisez 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 à une même famille. Par exemple, je n'ai 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 notre code soit lisible et simple à comprendre. De plus, je vous invite à espacer votre code. Les lignes d'espace allègeront votre code et ne le rendront pas plus gros en terme de poids.
Passons maintenant à la fonction FP1. Nous demandons a l'utilisateur de saisir un nombre, puis nous l'enregistrons (voir analyse fonctionnelle et structurelle).
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'à écrire 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.
Voilà. Ceci fait, nous pouvons passer à la fonction FP2.
Fonction FP2 : Calcul
Fichier main.cpp - fonction main :
//Fonction permettant à l'utilisateur de saisir le second nombre
cin >> intNombre2;
//Test pour déterminer le signe de l'opération et calcule l'opération
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 à l'intérieur du test sont en guillemets simples. Ils donnent alors leur numéro de caractère plutôt que le caractère lui même. Le double égal est nécessaire, car c'est un opérateur de comparaison, la ligne signifie :
si chrOperand vaut '+' alors exécutons le code.
Si nous avions mis un signe égal simple cela nous aurait 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'à coder la fonction FP3.
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 compiler et s'exécuter.
Saisissez 10 et faites entrée.
Saisissez + et faites entrée.
Saisissez 2 et faites entrée.
Le résultat de l'opération 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 à comprendre le fonctionnement. C'est pour cela que nous avons une phase de post-développement.
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 convivial.
La première des choses qui frappe 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 d'autre 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 à 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 à l'utilisateur de saisir le signe de l'operation cout << "Entrez le signe de l'operation + - * /" << endl; cin >> chrOperand; //Fonction permettant à 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'opération à l'écran cout << "Le résultat est" << endl; cout << intResultat << endl;
C'est mieux comme ça. Il reste cependant quelques bugs :
- Si nous mettons un nombre à virgule, le programme ne fait pas ce qu'on lui demande.
- Si nous mettons un autre caractères que les signes + - * / pour le signe de l'opération le programme ne fait pas ce qu'on lui demande.
Le premier bug est plus que fâcheux et le pire des deux.
Le deuxième est moins fâcheux mais plus long à rétablir.
Nous nous occupons donc des problèmes les plus fâcheux aux moins fâcheux.
Pour le premier bug, c'est très 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 :
/********************************** Définition et initialisation des variables **********************************/ //variable contenant les nombres saisies double dblNombre1 = 0.0, dblNombre2 = 0.0; //variable contenant le résultat de l'opération double dblResultat =0.0; //variable contenant le signe de l'opération char chrOperand = NULL;
N'oubliez pas de changer le préfixe de la variable dans tout le code, ni de changer l'initialisation en 0.0 car c'est comme cela que l'on passe un nombre à 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'erreur bête.
Une simple boucle de test de la saisie corrigera le second bug, mais nous verrons ceci dans le prochain tutoriel.
Récapitulatif
Nous avons vu pas mal de bases du c++ dans ce chapitre. Apprenez à les maitriser 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 assimilé, passez au prochain tutoriel.
Bases vues dans ce tutoriel :
- Définir 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 à partir d'une saisie au clavier (cin)
- Afficher a l'écran un message ou une variable. (cout)
- Une nomenclature pour les variables
- Insérer des commentaires
- Une méthode pour bien concevoir son projet.
Complément - Notation des versions
Je note les versions comme suit: x,ya
- x : numéro de version principale. Quand la calculatrice aura les fonctions que nous voudrons implémenter et sans bug, il passera à 1.
- y : numéro de fonctionnalité. Quand nous ajouterons des fonctionnalités à la calculatrice, ce numéro augmentera. Pour le moment, il est à 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 à son premier stade de développement. Elle n'a que les fonctionnalités d'opérations de base et il reste des bugs.
Conclusion
Je finirais ce tutoriel 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 tutoriel a pu vous aider et qu'il vous a plu. Bon courage pour la suite.
Merci à tous.