Débutez en c++ n°2
Débutez en c++ n°2
Description
Ce tutoriel est la suite de Débutez en c++. Il incorpore les fonctions personnalisées, les tableaux, les boucle for, while, la fonction switch, et la portées des variables.
Liens Vers les autres tutoriels de la série :
- [/faq/585-debutez-en-c Débutez en C++
- [Débutez en C++ n°2]
- Débutez en C++ n°3
- Débutez en C++ n°4
Bioopo
Le 29/12/2006
Introduction
Nous allons commencer ce second tutoriel par la refonte complète du code. Nous allons voir ce qu'est une fonction, l'appliquer à notre projet et résoudre les bugs de la version 0.1a.
Pourquoi des fonctions dans un projet si simple?
Simplement pour apprendre. Car bien que le code ne fasse que quelques lignes, il en contiendra bien plus a la fin du projet. Et tout mettre dans la fonction main serait suicidaire (pour la résolution des bugs). Je ne réécrirais pas les bases de la conception, elles sont dans le premier tutoriel. Nous n'ajouterons qu'une seule amélioration a ce projet pour ce tutoriel, la fonction servant à enlever le bug de saisie des opérateurs.
Connaissances requises
Les connaissances requises sont celles acquises au tutoriel numéro 1 : Débutez en c++. Il faut savoir :
- Définir une variable et son type. (char, int et double)
- Initialiser les variables
- Faire un calcul de base en mathématique
- Créer une fonction de test standard (if, if else if)
- Enregistrer une variable à partir d'une saisie au clavier (cin)
- Afficher à l'écran un message ou une variable. (cout)
- Insérer des commentaires
Cahier des charges
Le but du programme
Le but du programme est d'afficher le résultat d'une opération saisie par l'utilisateur.
Les moyens mis en oeuvre
Nous allons utiliser le logiciel dev-c++ avec un nouveau projet en mode console.
Pourquoi le mode console?
Simplement car pour la calculatrice que nous allons programmer, une interface graphique est inutile. Surtout, elle nous rendrait l'apprentissage plus difficile, ce qui n'est pas le but. L'exécutable de la calculatrice ne devra pas dépasser 500 Ko.
Les mises à jour
Correction du bug concernant la saisie utilisateur, en ajoutant une fonction de vérification de saisie.
Analyse fonctionnelle
Pour notre second tutoriel, nous devons modifier les analyses fonctionnelles et structurelles de notre projet initial. Nous rajoutons la fonction FP4 : Vérification. A partir de ce tutoriel, nous ne verrons que les nouvelles fonctionnalités ou celles modifiées.
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 FP4 : Vérification des saisies |
| 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. |
Fonction FP4 : Vérification saisie
| Spécificités | Détails |
|---|---|
| Code d'identification | FP4 |
| Nom | Vérification saisie |
| Objectif | Validation de la saisie utilisateur |
| Données fournies | Saisie enregistrée |
| Actions utilisateur | Aucune |
| Données sorties | Saisie validée |
| Sous-fonctions | Aucune |
| Description détaillée | La Fonction devra vérifier la saisie utilisateur et la valider. Si elle n'est pas valide, l'utilisateur devra saisir une nouvelle opération. |
Analyse structurelle
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. |
Pour la fonction de vérification, nous devons changer les types de variables. Ce sera plus simple pour la suite. Nous n'allons plus utiliser directement des variables de type double, mais une nouvelle fonctionnalité : les tableaux, plus précisément , des tableaux de type char.
Les tableaux
Les tableaux sont, comme des variables, une allocation d'un espace mémoire, à ceci prés, qu'ils peuvent contenir plusieurs données ( attention toutes du même type). Ça évite d'utiliser plusieurs variables. Par exemple, si vous avez des nombres à enregistrer, plutôt que de définir intNum1, intNum2, intNum3 .... vous utiliserez un seul tableau que vous remplirez.
Pour notre exemple, le tableau nous servira à enregistrer les 2 nombres, mais surtout à pourvoir vérifier les saisies car avec des variables de types char, nous pouvons facilement faire des vérifications de données.
Un tableau se définit comme ceci :
type_du_tableau nom_du_tableau[nombre_d'elements_maximal]
Comme le tableau est une variable, il utilise les mêmes types.
Pour initialiser un tableau, il faut faire une boucle sur tous ces éléments.
La boucle for
La Fonction for permet de faire une boucle dans un programme tant que la condition n'est pas remplie. Elle se traduit par : Pour i égale zéro, tant que i est inférieur à deux, alors nous exécutons le code, puis nous ajoutons 1 a la variable i. Quand i n'est plus inférieur à 2, nous passons à l'instruction suivante.
for(int i=0;i<2;i++)
{
code a exécuter;
}
Pour les tableaux de petites tailles comme le notre, il est plus rapide d'utiliser cette façon :
double dblNomre[2] = { 0.0,0.0};
Pour les tableau de type char, nous pouvons utiliser ces technique ou tous simplement
char chrTableau[5] = "salut"
Récapitulatif des variables et fonctions de FP1
| Variables et fonctions | Type | Détails |
|---|---|---|
| chrNombre[10] | char | Enregistre les saisies utilisateur |
| 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 FP4.
Fonction FP4 : Vérification saisie
| Spécificités | Détails |
|---|---|
| Code d'identification | FP4 |
| Nom | Vérification saisie |
| Objectif | Validation de la saisie utilisateur |
| Données fournies | Saisie enregistrée |
| Données sorties | Saisie validée |
| Description détaillée | La Fonction devra vérifier la saisie utilisateur et la valider. Si elle n'est pas valide, l'utilisateur devra saisir une nouvelle opération |
Cette fonction se divise en deux parties, la vérification de la saisie et le chemin a emprunter en fonction de cette vérification. Si la saisie a passé le test de validation, alors nous calculons, sinon nous redemandons la saisie. De plus, il faut un code de vérification pour les nombres et un autre pour l'opérateur. Nous pourrions tapez l'opération sur une seule ligne, puis vérifier chaque partie. Nous le ferons dans le prochain tutoriel, car nous devons déjà assimiler ces fonctions sans ajouter d'autres complications.
Pour la vérification, nous allons faire appel au code ascii. C'est un code standard, qui code les caractères avec des nombres.
Pourquoi utiliser cela?
Tout simplement parce que je suis fainéant... Non, car c'est plus simple. Le code ascii regroupe les chiffre 0 à 9 avec des codes qui se suivent. Cela évite de faire un test par chiffre. Le code ascii des nombres commence à 48 pour le zéro et finit à 57 pour le neuf. Il suffit donc, pour chaque élément du tableau, de faire un test pour savoir si le caractère tapé à un code ascii compris entre 48 et 57.
Pour les signes de l'opération, comme il ne se suivent pas dans le code ascii et que pour le moment ils sont limité à 4, nous préféreront les tester sans leur code ascii. Cela vous montrera deux façons de procéder. Pour avoir le code ascii, il suffit de convertir le caractère en int avec la fonction int(caractere). Nous imbriquons donc une boucle for avec un test if pour valider la saisie.
Pour le tableau de caractères, nous initialiserons les éléments avec la valeur 0.
Les fonctions personnalisées
Nous parlons ici des fonctions, ce sont des blocs de code distinct que l'on appelle pour effectuer une tache spécifique. Par exemple, nous avons besoin de faire une vérification sur le nombre saisi, comme nous avons plusieurs saisies, plutôt que de copier deux fois le même code à différents endroits du code, nous allons utiliser une fonction, il ne restera plus qu'a l'appeler dans notre code pour l'utiliser.
Une fonction est définit comme la fonction main.
Type_de_retour_de_la_fonction nom_de_la_fonction(arguments)
Le type de retour est le type de donnée renvoyée par la fonction. Il y a les types standard, les mêmes que les variables plus le type void, qui est spécifique aux fonctions. En fait, il dit au compilateur qu'il n'y a pas de retour de fonction.
Les arguments sont des données (variables, données numériques ou chaines de caractères) dont la fonction a besoin pour exécuter sa partie de code. Les arguments servent à transmettre à la fonction ces données.
Pour que votre programme puisse l'utiliser, elle doit être déclarée avant l'appel de celle-ci.
Pour cela, il faut placer une déclaration de la fonction, c'est la même chose, mais avec un point-virgule à la fin, avant la fonction main.
Comme nous allons utiliser les fonctions, une notion va devoir être vu, la portée des variables. Il existe deux types de portées, la variable locale, celle que nous utilisons depuis le début, et la variable globale. La Différence fondamentale est qu'une variable locale n'est utilisable que dans le bloc de code ou elle a été créée. Toutes nos variables sont locales à la fonction main.
La variable globale est utilisable dans tout le programme. Pour utiliser une variable globale, il suffit de la déclarer hors des fonctions. On les place en général dans un fichier header (.h). Pour les petits programmes comme celui-ci, je vous recommande de créer un fichier main.h pour déclarer vos fonctions et vos variables globales.
Pour ce faire, dans dev-c++, faites fichier ->Nouveau Fichier, puis enregistrer le en header files (.h) avec le nom main. Ensuite pour l'utiliser, il faut l'inclure dans le fichier main.cpp
A la suite des autres fichiers à inclure mettre : #include "main.h"
Pour ce programme, nous utiliserons des variables globales pour les types char et booléenne, locales pour les types double et nous déclarerons les fonctions dans ce fichier, donc vous pouvez le créer.
Récapitulatif des variables et fonctions de FP4
| Variables et fonctions | Type | Détails |
|---|---|---|
| chrNombre[10] | char | Enregistre les saisies utilisateur |
| dblNombre[2] | double | Enregistre les nombres saisis validés |
| chrOperand | char | Enregistre le signe de l'opération |
| bErreur | Bool | Enregistre la présence d'erreur |
| bDecimal | Bool | Enregistre la présence du point décimal |
| If | Fonction de test | |
| Switch | Fonction de choix | |
| For | Fonction de boucle | |
| While | Fonction de boucle |
Développement
Nous avons donc créé le fichier main.h et nous l'incluons dans le fichier main.cpp
....... #include <cstdlib> #include <iostream> #include "main.h" .......
Le fichier main.h
Voici le fichier main.h
/**********************************
Program : calc2007
Fichier : main.h
Créateur : bioopo
Création : 29/12/2006
logiciel : dev-c++
Version : 0.1a
Modification : 29/12/2006
**********************************/
/**********************************
Ce fichier déclare les fonctions et les variables globales utilisées dans le programme
**********************************/
/**********************************
Définition des variables
**********************************/
//Variable contenant la saisie de l'opérateur.
char chrNombre[10] = {'0','0','0','0','0','0','0','0','0','0'};
//variable contenant le signe de l'opération
char chrOperand='0';
//variable de présence d'erreur
bool bErreur = true;
//variable de présence de decimal
bool bDecimal = false;
/**********************************
Déclaration des fonctions
**********************************/
//Fonction permettant la saisie utilisateur
void Saisie_Utilisateur(int intChoix);
//Fonction permettant la vérification de la saisie utilisateur
void Verification_Saisie(int intChoix);
Nous définissons deux tableaux pour les nombres saisies. La première, de type double , contiendra les nombres pour effectuer le calcul, alors que la seconde servira pour la vérification de la saisie. Nous l'initialisons donc avec des zéros, pour ne pas avoir d'erreur si nous l'initialisions avec rien.
Les deux variables booléennes serviront dans la phase de vérification, pour le moment, nous les initialisons.
Les déclaration de fonctions servent à pouvoir utiliser ces fonctions à l'intérieur de notre programme.
Passons à la fonction FP1. Nous demandons, à l'utilisateur, de saisir un nombre, puis nous l'enregistrons (voir analyse fonctionnelle et structurelle). Nous allons passer ce code dans une fonction, pour pouvoir la réutiliser.
Fonction FP1 : Saisie utilisateur
Fichier main.cpp - Fin de fichier
........
system("PAUSE");
return EXIT_SUCCESS;
}
void Saisie_utilisateur(int intChoix)
{
switch(intChoix)
{
case 1:
cin >> chrNombre;
break;
case 2:
cin >> chrOperand;
break;
}
}
La fonction de Saisie_utilisateur est d'enregistrer la saisie. Par rapport au premier tutoriel où nous saisissions les trois saisies d'affilées, nous intercalerons entre chaque saisie la fonction FP2 verification, pour vérifier la saisie chacune leur tour. Dans le prochain tutoriel, comme nous n'effectuerons qu'une seule saisie, la vérification ne s'intercalera pas.
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.2a" << endl; cout << "entrez le premier nombre" << endl; Saisie_utilisateur(1); //Fonction permettant à l'utilisateur de saisir le signe de l'opération cout << "Entrez le signe de l'operation + - * /" << endl; Saisie_Utilisateur(2); //Fonction permettant à l'utilisateur de saisir le second nombre cout<<"Entrez le second nombre" << endl; Saisie_Utilisateur(1); .......
Cette ligne de code appelle la fonction créée, avec comme paramètre 1.
Si nous regardons la fonction Saisie_Utilisateur de plus près, ce paramètre, grâce à la fonction de choix switch, permet de choisir quel code va être exécuté. En l'occurrence, nous demandons d'enregistrer la saisie dans chrNombre. Une fois effectué, le programme revient à l'instruction suivante de l'appel de fonction dans la fonction qui l'a appelé.
Fonction FP4 : Vérification saisie
Fichier main.cpp - Fin de fichier :
........
case 2:
cin >> chrOperand;
break;
}
}
/**********************************
Fonction Verification_Saisie
Fonction permettant la vérification de la saisie utilisateur
**********************************/
void Verification_Saisie(int intChoix)
{
//Fonction permettant un choix pour une vérification de la saisie
//en fonction de l'argument nombre : 1 ou opérateur : 2
switch(intChoix)
{
case 1:
//Nous définissons qu'il y a une erreur pour la première saisie avant vérification
bErreur = true;
//Boucle tant qu'il y a une erreur
while(bErreur == true)
{
//Définissons qu'il n'y a pas de décimal de mise avant la vérification
bDecimal = false;
//Teste la saisie caractère après caractère
for(int i = 0; i < 10; i++)
{
//test si nous rencontrons la fin de la saisie
if(int(chrNombre[i]) == 0)
{
//Il n'y a pas d'erreur
bErreur = false;
//Fin de vérification de saisie
break;
}
//Sinon, on teste si le caractere est un chiffre
else if(int(chrNombre[i]) > 47 and int(chrNombre[i]) < 58)
//Il n'y a pas d'erreur
bErreur = false;
//Sinon, on teste si le caractère est un point et s'il n'y en a déjà pas un
else if(int(chrNombre[i]) == 46 and bDecimal == false)
{
//Il n'y a pas d'erreur,
bErreur = false;
//Nous ne pourrons plus mettre de point
bDecimal = true;
}
//Sinon, il y a une erreur
else
bErreur = true;
//Si il y a une erreur, nous sortons de la vérification de saisie
if(bErreur == true)
break;
}
//Si il y a une erreur, nous demandons de rentrer un nouveau nombre
if(bErreur == true)
{
cout << "vous n'avez pas rentré un nombre correct" << endl;
cout << "entrez un nombre correct" << endl;
Saisie_Utilisateur(1);
}
}
break;
case 2:
//Nous définissons qu'il y a une erreur pour la première saisie avant vérification
bErreur = true;
//Boucle tant qu'il y a une erreur
while(bErreur == true)
{
//Teste si le caractère est un opérateur reconnu
if(chrOperand == '+' or chrOperand == '-' or chrOperand == '*' or chrOperand == '/')
{
//il n'y a pas d'erreur
bErreur = false;
}
//Sinon, il y a une erreur
else
{
bErreur = true;
}
//Si il y a une erreur, nous demandons de rentrer un nouvel opérateur
if(bErreur == true)
{
cout << "vous n'avez pas rentré un opérateur correct" << endl;
cout << "entrez un opérateur correct" << endl;
Saisie_Utilisateur(2);
}
}
break;
}
}
Nous avons un switch comme dans la fonction de saisie, pour déterminer qu'elle est le type de données à vérifier ( nombre ou opérateur) .
Commençons par la case opérateur, car elle est plus simple a assimiler.
Nous commençons par mettre la variable de présence d'erreur à true, car nous partons du principe que la première saisie, avant d'être vérifiée, peut contenir des erreurs.
Ensuite, nous faisons une boucle qui exécutera sa portion de code tant qu'il y aura une erreur.
Ensuite, on teste si le caractère saisi est bien un opérateur reconnu ( + - * / ). S'il est reconnu, nous validons la saisie en mettant la variable bErreur à false, ce qui aura pour effet de quitter la boucle.
Si le caractère n'est pas un opérateur reconnu, nous ne validons pas la saisie, nous mettons la variable bErreur à true puis nous demandons de saisir un nouvel opérateur.
Une fois ceci compris, passez à la fonction de vérification des nombres, qui elle est un peu plus complexe. Nous commençons par mettre la variable de présence d'erreur à true, car nous ne partons du principe que la première saisie avant d'être vérifiée peut contenir des erreurs.
Ensuite, nous faisons une boucle qui exécutera sa portion de code tant qu'il y aura une erreur.
Jusque la, c'est comme la fonction pour les opérateurs, mais ça se complique, car en plus des chiffres, un nombre peut avoir une partie décimale. La variable bDecimal est là pour ça.
Nous la définissons à false car, sinon, nous aurons une erreur puisqu'il ne prendra pas en compte notre décimale et nous mettra une erreur.
Ensuite, nous effectuons une boule for pour valider la saisie caractères après caractères.
Comme l'enregistrement dans un tableau se finit toujours par un caractère nul, nous testons, grâce au code ascii du caractère nul (code 0), si nous sommes à la fin de la saisie. Si c'est le cas, nous sortons de la boucle for et validons le nombre. Si la fin n'est pas atteinte, nous testons si le caractère est un chiffre, si c'est le cas nous passons au suivant, sinon nous testons si c'est une décimale et si la décimale n'est pas déjà utilisée. Si c'est la première décimale, nous passons au caractère suivant. Sinon, il y a une erreur de saisie et nous demandons de saisir un nouveau nombre.
Nous appelons la fonction de vérification dans la fonction main.
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.2a" << endl;
cout << "entrez le premier nombre" << endl;
Saisie_Utilisateur(1);
//Fonction de vérification de la saisie
Verification_Saisie(1);
//Sauvegarde de la saisie
dblNombre[0] = atof(chrNombre);
//Fonction permettant a l'utilisateur de saisir le signe de l'operation
cout << "Entrez le signe de l'operation + - * /" << endl;
Saisie_Utilisateur(2);
//Fonction de vérification de la saisie
Verification_Saisie(2);
//Fonction permettant a l'utilisateur de saisir le second nombre
cout<<"Entrez le second nombre" << endl;
Saisie_Utilisateur(1);
//Fonction de vérification de la saisie
Verification_Saisie(1);
//Sauvegarde de la saisie
dblNombre[1] = atof(chrNombre);
//Test pour déterminer le signe de l'operation et calcul l'operation
if(chrOperand == '+')
{
dblResultat = dblNombre[0] + dblNombre[1];
}
......
Nous appelons donc la fonction de vérification, puis nous sauvegardons la saisie dans la variable contenant le nombre. La conversion est effectuée grâce a la fonction atof qui convertie une chaine de caractère (chrNombre) en un nombre de type double que nous enregistrons dans le premier élément du tableau de type double (dblNombre[0]). Le premier élément d'un tableau est toujours 0. Pour le second nombre, la méthode est la même.
Pour l'opérateur, il n'est pas nécessaire de l'enregistrer dans une autre variable car la variable chrOperand le contient déjà.
Nous avons déjà vu le reste, donc notre partie de développement est terminée. Passons a la phase de post-développement.
Post-développement
Voilà, grâce à la fonction de vérification, nous avons éliminé le bug de la version 0.1a.
Dans cette version, le seul bug que je connaisse, même s'il ne s'agit pas vraiment d'un bug, mais plutôt de commodité de lecture, c'est quand nous entrons un grand nombre ex : 100000000.
Suivant l'opération, il nous le note en puissance de dix (écriture scientifique).
Donc nous pouvons notez que cette version est la version 0.2b
Récapitulatif
Bases vues dans ce tutoriel:
- 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.
Nous avons vu dans ce tutoriel et le précédent:
- Les types de variables : int, double, char, bool.
- 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.
Complément
Retournons à notre projet. A chaque changement de version, il est conseillé de faire une sauvegarde du programme et de ses documents. Pour ma part, je crée un répertoire archives, puis un répertoire avec le nom de mon programme puis enfin un répertoire avec le numéro de version et je copie mon programme et mes documents dedans. C'est sur, c'est pas le meilleur moyen, mais il est sur. N'oubliez pas de changer le numéro de version au début du fichier, et d'écrire les commentaires du fichier pour le fichier main.h
Pour les commentaires, plus vous mettrez d'informations, mieux se sera, mais attention, des informations redondantes à changer dans tous les fichiers, à chaque changement de version est vraiment chiant. Mais par exemple, une version du fichier et nom du programme, peut être bien, car il vous donnera des informations sur ou vous en êtes des fonctions de chaque fichier.
Le seul conseil que je vous donne et de tester d'abord votre programme pour ce qu'il est censé accomplir (pour ce programme, faire diverses opérations standard, avec ou sans décimales, des grands nombres, des petits...) puis passez à ce qu'il n'est pas censé accomplir, mettre des lettres ou des opérateurs dans les nombres, des chiffres et des lettres dans les opérateurs, sans saisie (appuyer sur la touche entrée directement), pour découvrir une faille du programme. Ensuite, vous pourrez dire que votre version est stable et sans bugs inconnus (il peut y avoir des bugs connus, et ne pas les corriger, si vous ne savez pas encore comment faire, comme dans la version 0.1a, mais il faudra les corriger par la suite dans les versions suivantes).
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 tutoriel suivant. Les possibilités de programmes sont déjà plus vastes que pour le premier tutoriel, et 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 a tous.