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

Débutez en c++

Juin 2017


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 :



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é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
Description détailléeLa 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ésDétails
Code d'identificationFP1
NomEnregistrement saisie
ObjectifEnregistrer les saisies utilisateur
Données fourniesAucune
Actions utilisateurSaisie de l'opération
Données sortiesSaisie enregistrée
Sous-fonctionsAucune
Description détailléeLa Fonction devra enregistrer la saisie utilisateur.

Fonction FP2 : Calcul


SpécificitésDétails
Code d'identificationFP2
NomCalcul
ObjectifEffectuer le calcul de l'opération saisie par l'utilisateur
Données fourniesSaisie enregistrée
Actions utilisateurAucune
Données sortiesRésultat du calcul
Sous-fonctionsAucune
Description détailléeLa 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ésDétails
Code d'identificationFP3
NomAffichage du résultat
ObjectifAfficher le résultat de l'opération
Données fourniesRésultat du calcul
Actions utilisateurAucune
Données sortiesRésultat affiché
Sous-fonctionsAucune
Description détailléeLa 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ésDétails
Code d'identificationFP1
NomEnregistrement saisie
ObjectifEnregistrer les saisies utilisateur
Actions utilisateurSaisie de l'opération
Données sortiesSaisie enregistrée
Description détailléeLa 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 fonctionsTypeDétails
intNombre1intEnregistre le premier nombre saisi
intNombre2intEnregistre le second nombre saisi
chrOperandcharEnregistre le signe de l'opération
cinDemande la saisie et l'enregistre

L'analyse de cette fonction est terminée. Nous pouvons passer à la fonction FP2

Fonction FP2 : Calcul


SpécificitésDétails
Code d'identificationFP2
NomCalcul
ObjectifEffectuer le calcul de l'opération saisie par l'utilisateur
Données fourniesSaisie enregistrée
Données sortiesRésultat du calcul
Description détailléeLa 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 fonctionsTypeDétails
intNombre1intEnregistre le premier nombre saisi
intNombre2intEnregistre le second nombre saisi
chrOperandcharEnregistre le signe de l'opération
intResultatintEnregistre le résultat de l'opération
IfChoisi 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ésDétails
Code d'identificationFP3
NomAffichage du résultat
ObjectifAfficher le résultat de l'opération
Données fourniesRésultat du calcul
Données sortiesRésultat affiché
Description détailléeLa 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 fonctionsTypeDétails
intResultatintEnregistre le résultat de l'opération
coutAffiche 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.

A voir également

Publié par bioopovega.
Ce document intitulé «  Débutez en c++  » 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ébuter en C++ sous Windows avec les principaux IDE
Débutez en c++ n°2