Bioopo
Bioopo@neuf.fr
Le 29/12/2006
Comment debuter en c++
I - Introduction
Nous allons commencer ce second tutorial par la refonte complète du code. Nous allons voir ce qu'est une fonction, l'appliquez à 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 tutorial. Nous n'ajouterons qu'une seule amélioration a ce projet pour ce tutorial, la fonction servant a enlever le bug de saisie des opérateurs.
II - Connaissances requises
Les connaissances requises sont celles acquises au tutorial numero 1 : Débutez en c++. Il faut savoir :
-
Definir une variable et son type. (char, int et double)
-
Initialiser les variables
-
faire un calcul de base en mathematique
-
créer une fonction de test standard (if, if else if)
-
Enregistrer une variable a partir d'une saisie au clavier (cin)
-
Afficher a l'ecran un message ou une variable. (cout)
-
inserer des commentaires
III - Cahier des charges
1 - Le but du programme
Le but du programme est d'afficher le résultat d'une opération saisie par l'utilisateur.
2 - Les moyens misent en oeuvre
Nous allons utiliser le logiciel dev-c++ avec un nouveau projet en mode console. (pourquoi le mode console, simplement car pour la calculatrice que nous allons programmer, une interface graphique est inutile, surtout elle nous rendrait l'apprentissage plus difficile, ce qui n'est pas le but). L'éxécutable de la calculatrice ne devra pas dépasser 500 Ko.
3 - Les mises à jour
Correction du bug concernant la saisie utilisateur, en ajoutant une fontion de verification de saisie.
IV - Analyse fonctionnelle
Pour notre second tutorial, nous devons modifier les analyses fonctionnelles et structurelles de notre projet initial, nous rajoutons la fonction FP4 : Vérification. A partir de ce tutorial, nous ne verrons que les nouvelles fonctionnalités ou celles modifiées.
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 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. |
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 validé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. |
4 - 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 |
5 - 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 fournis | 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 operation |
V - Analyse structurelle
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. |
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 precisément , des tableaux de type char.
2 - Les tableaux
Les tableaux sont, comme des variables, une allocation d'un espace mémoire, a ceci prés, qu'ils peuvent contenir plusieurs données ( attention toutes du même type), ca evite d'utiliser plusieurs variables. Par exemple, si vous avez des nombres a enregistrer, plutot que de définir intNum1, intNum2, intNum3 .... vous utiliserez un seul tableau que vous remplirez.
Pour notre exemple, le tableau nous servira a enregistrer les 2 nombres, mais surtout a pourvoir verifier les saisies car avec des variables de types char, nous pouvons facilement faire des verifications de données.
Un tableau se définit comme ca :
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.
3 - 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 executons le code, puis nous ajoutons 1 a la variable i. Quand i n'est plus inférieur à 2, nous passons a l'instruction suivante.
for(int i=0;i<2;i++)
{
code a éxécuter;
}
Pour les tableaux de petites tailles comme le notre, il est plus rapide d'utiliser cette facon : 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.
4 - 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 fournis | 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 operation |
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érifié chaque partie, nous le ferons dans le prochain tutorial, car nous devons déjà assimilé ces fonctions sans rajouter d'autres complications.
Pour la verification, 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 faineant, non car c'est plus simple. Le code ascii regroupe les chiffre 0 à 9 avec des codes qui se suivent.Cela evite de faire un test par chiffre. Le code ascii des nombres comment à 48 pour le zero et finit à 57 pour le neuf. Il suffit donc pour chaque élément du tableau de faire un test pour savoir si le caractere tapé à un code ascii compris entre 48 et 57.
Pour les signes de l'operation, 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 facons de procéder. Pour avoir le code ascii, il suffit de convertir le caractere 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 caractere, nous initialiserons les éléments avec la valeur 0.
5 - 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, plutot que de copier deux fois le même code a 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ées renvoyé par la fonction. Il y a les types standard (les même 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 chains de caractères) que la fonction a besoin pour executer 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 a la fin, avant la fonction main.
Comme nous allons utiliser les fonctions, une notion va devoir être vu, la porté des variables, Il existe deux types de portés, la variable locale, celle que nous utilisons depuis le début, et la variable globale. La Différence fondamentale est qu'une variable local n'est utilisable que dans le bloc de code ou elle a été créée, toutes nos variables sont locale à 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 fichiers 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 a inclure mettre : #include "main.h"
Pour ce programme, nous utiliserons des variables globales pour les types char et booléenne, local 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 |
VI - 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"
.......
1 - Le fichier main.h
Voici le fichier main.h
/**********************************
Program : calc2007
Fichier : main.h
Créateur : bioopo
Mail : bioopo@neuf.fr
Creation : 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
**********************************/
/**********************************
Definition des variables
**********************************/
//Variable contenant la saisie de l'operateur.
char chrNombre[10] = {'0','0','0','0','0','0','0','0','0','0'};
//variable contenant le signe de l'operation
char chrOperand='0';
//variable de presence d'erreur
bool bErreur = true;
//variable de presence 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 premiere, 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 danc 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 a pouvoir utiliser ces fonctions a l'intérieur de notre programme.
Passons a la fonction FP1, nous demandons a 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.
2 - 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 tutorial où nous saisissions les trois saisies d'affilées, nous intercalerons entre chaque saisies la fonction FP2 verification, pour vérifier la saisie chacune leur tour. Dans le prochain tutorial, comme nous n'effecturons qu'une seul saisie, la vérification ne s'intercaleras pas.
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 permettant a l'utilisateur de saisir le signe de l'operation
cout << "Entrez le signe de l'operation + - * /" << endl;
Saisie_Utilisateur(2);
//Fonction permettant a l'utilisateur de saisir le second nombre
cout<<"Entrez le second nombre" << endl;
Saisie_Utilisateur(1);
.......
Cette ligne de code appelle la fonction créé, avec comme parametre 1.
Si nous regardons la fonction Saisie_Utilisateur de plus pres, ce paramètre, grace a la fonction de choix switch, permet de choisir quel code va être executé. En l'occurence, nous demandons d'enregistrer la saisie dans chrNombre. Une fois effectuez le programme revient à l'instruction suivante de l'appel de fonction dans la fonction qui l'a appelé.
3 - 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 verification de la saisie en fonction de l'argument nombre : 1 ou operateur : 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 caractere apres caractere
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 verification 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 caractere est un point et s'il n'y en a déja 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 rentrez 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 caractere est un operateur 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 rentrez un nouvel operateur
if(bErreur == true)
{
cout << "vous n'avez pas rentré un operanteur correct" << endl;
cout << "entrez un operateur correct" << endl;
Saisie_Utilisateur(2);
}
}
break;
}
}
Nous avons un switch comme dans la fonction de saisie, pour determiner qu'elle est le type de données à vérifier ( nombre ou opérateur) .
Commencons par la case opérateur, car elle est plus simple a assimiler.
Nous commencons 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érifier 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 test si le caractère saisie est bien un opérateur reconnu ( + - * / ) et s'il est reconnu, nous validons la saisie en mettant la variable bErreur a false, ce qui aura pour effet de quitter la boucle.
Si le caractere n'est pas un operateur reconnu, non ne validons pas la saisie, nous mettons la variable bErreur a 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 commencons 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érifier 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 ca se complique, car en plus des chiffres, un nombre peut avoir une partie décimale. La variable bDecimal est la pour ca.
Nous la définissont à false car sinon, nous auront une erreur car il ne prendra pas en compte notre décimal et nous mettra une erreur.
Ensuite, nous effetuons 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, grace au code ascii du caractère nul (code 0), si nous sommes a la fin de la saisie.NousSi 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écimal et si la décimal n'est pas déjà utilisé. Si c'est la première décimal, 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 verification 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 apellons donc la fonction de vérification, puis nous sauvegardons la saisie dans la variable contenant le nombre. La convertion est effectuée grace 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éja.
Nous avons déjà vu le reste, donc notre partie de développement est terminé, passons a la phase de post-développement.
VII - Post-développement
Voilà, grace a 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 plutot 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
VIII - Récapitulatif
Base vu dans ce tutorial:
-
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 tutorial 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.
IX - 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éer un répertoire archives, puis un répertoire avec le nom de mon programme puis enfin un répertoire avec le numero 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 numero de version au début du fichier, et d'écrire les commentaire du fichier pour le fichier main.h
Pour les commentaires, plus vous mettrez d'informations, mieux se sera, mais attention, des informations redondantes a changer dans tous les fichiers a chaque changement de version est vraiment chiant. Mais par exemple , une version du fichier et non 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 donnes 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écimal, des grands nombres, des petits...) puis passez à ce qu'il n'est pas sencé accomplir, mettre des lettre ou des operateurs dans les nombres, des chiffres et des lettres dans les operateurs, 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).
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. Les possibilités de programmes sont déjà plus vastes que pour le premier tutorial, 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 tutorial a pu vous aider et qu'il vous a plu. Bon courage pour la suite.
Bientôt le prochain tutorial.
Merci a tous.