> Le Site du Zéro - Informatique

> Cours

> Tutoriels

> Programmation

> C++

> Programmez avec le langage C++

> [Théorie] Découverte de la programmation en C++

> Une vraie calculatrice

> Lecture du tutoriel

Une vraie calculatrice

Par

Mathieu Nebra (M@teo21) et Avatar

Matthieu Schaller (Nanoc)

Mise à jour : 27/05/2011

Difficulté : Facile Facile

Durée d'étude : 1 jour

75 639 visites depuis 7 jours, dont 1 812 sur ce chapitre classé 5/786

J'ai commencé à vous parler de variables dans le chapitre précédent en vous présentant la mémoire d'une calculatrice. Notre ordinateur étant une super-super-super-calculatrice, on doit pouvoir lui faire faire des calculs et pas juste sauvegarder des données. J'espère que ça vous intéresse, parce que c'est ce que je vais vous apprendre à faire.

Nous allons commencer en douceur avec la première tâche qu'on effectue sur une calculette. Vous voyez de quoi je veux parler ? Oui c'est ça, écrire des nombres pour les mettre dans la machine. Nous allons donc voir comment demander des informations à l'utilisateur et comment les stocker dans la mémoire. Nous aurons donc besoin de .... variables !

Dans un deuxième temps, je vais vous présenter comment effectuer de petits calculs. Finalement, comme vous savez déjà comment afficher un résultat, vous pourrez mettre tout votre savoir en action avec un petit exercice.

Retour en haut

Sommaire du chapitre :

Demander des informations à l'utilisateur
Modifier des variables
Les constantes
Un premier exercice
Les raccourcis
Encore plus de maths !
Q.C.M.

Retour en haut

Demander des informations à l'utilisateur

Dans le chapitre précédent, je vous ai expliqué comment afficher des variables dans la console. Voyons maintenant comment faire le contraire, c'est-à-dire demander des informations à l'utilisateur pour les stocker dans la mémoire.

Lecture depuis la console

Vous l'aurez remarqué, le C++ utilise pas mal de mots tirés de l'anglais. C'est notamment le cas pour le flux sortant cout, qui doit se lire "c-out". Ce qui est bien, c'est qu'on peut immédiatement en déduire le nom du flux entrant. Avec cout, les données sortent du programme, d'où le out. Le contraire de out en anglais étant in, qui signifie "vers l'intérieur", on utilise cin pour faire entrer des informations dans le programme. cin se décompose aussi sous la forme "c-in" et se prononce "si-inne". C'est important pour les soirées entre programmeurs.

Ce n'est pas tout ! Associés à cout, il y avait les chevrons (<<). Dans le cas de cin, il y en a aussi, mais dans l'autre sens (>>).

Voyons ce que ça donne avec un premier exemple.

Code : C++ - Premier exemple de cin

#include <iostream>
using namespace std;

int main()
{
    cout << "Quel age avez-vous ?" << endl;

    int ageUtilisateur(0);      //On prepare une case memoire pour stocker un entier.

    cin >> ageUtilisateur;   //On fait entrer un nombre dans cette case.

    cout << "Vous avez " << ageUtilisateur << " ans !" <<  endl; //Et on l'affiche.

    return 0;
}

Je vous invite à tester ce programme. Voici ce que ça donne avec mon âge

:

Code : Console - Quel âge avez-vous ?

Quel age avez-vous ?
22
Vous avez 22 ans !

Que s'est-il passé exactement ?

Le programme a affiché le texte Quel age avez-vous ?. Jusque-là, rien de bien sorcier. Puis, comme on l'a vu précédemment, à la ligne 8, le programme demande une case mémoire pour stocker un int à l'ordinateur et il baptise cette case ageUtilisateur.
Ensuite, ça devient vraiment intéressant. L'ordinateur affiche un curseur blanc clignotant et attend que l'utilisateur écrive quelque chose. Quand celui-ci a terminé et appuyé sur Entrée, le programme prend ce qui a été écrit et met le contenu dans la case mémoire ageUtilisateur à la place du 0 qui s'y trouvait.
Finalement, on retombe sur quelque chose de connu, puisque le programme affiche une petite phrase et le contenu de la variable.

Une astuce pour les chevrons

Il arrive souvent que l'on se trompe dans le sens des chevrons. Vous ne seriez pas le premier à écrire cout >> ou cin <<, ce qui est faux.
Pour se souvenir du sens correct, je vous conseille de considérer les chevrons comme si c'étaient des flèches indiquant la direction dans laquelle les données se déplacent. Depuis la variable vers cout ou depuis cin vers votre variable.

Le mieux est de prendre un petit schéma magique. :magicien:

Schéma mnémotechnique indiquant le sens des chevrons à utiliser

Quand on affiche la valeur d'une variable, les données sortent du programme, on utilise donc une flèche allant de la variable vers cout. Quand on demande une information à l'utilisateur, c'est le contraire, la valeur vient de cin et va dans la variable.

Avec ça, plus moyen de se tromper !

D'autres variables

Évidemment, ce que je vous ai présenté marche aussi avec d'autres types de variables. Voyons ça avec un petit exemple.

Code : C++ - Lecture d'autres types de variables

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Quel est votre prenom ?" << endl;
    string nomUtilisateur("Sans nom");           //On crée une case mémoire pour contenir une chaine de caractères
    cin >> nomUtilisateur;                       //On remplit cette case avec ce qu'écrit l'utilisateur

    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.);                  //On crée une case mémoire pour stocker un nombre réel
    cin >> piUtilisateur;                        //Et on remplit cette case avec ce qu'écrit l'utilisateur
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pi vaut " << piUtilisateur << "." << endl;

    return 0;
}

Je crois que je n'ai même pas besoin de donner d'explications. Je vous invite néanmoins à tester pour bien comprendre en détail ce qui se passe.

Le problème des espaces

Avez-vous testé le code précédent en mettant votre nom et prénom ? Regardons ce que ça donne.

Code : Console - Les soucis d'Albert

Quel est votre prenom ?
Albert Einstein
Combien vaut pi ?
Vous vous appelez Albert et vous pensez que pi vaut 0.

L'ordinateur n'a rien demandé pour pi et le nom de famille a disparu ! Que s'est-il passé ?

C'est un problème d'espaces. Quand on appuie sur Entrée, l'ordinateur copie ce qui a été écrit par l'utilisateur dans la case mémoire. Mais, il s'arrête à la première espace ou au premier retour à la ligne. Quand il s'agit d'un nombre, cela ne pose pas de problèmes puisqu'il n'y a pas d'espaces dans les nombres.
Pour les string, le problème se pose. Il peut très bien y avoir une espace dans une chaîne de caractère. Et donc l'ordinateur va couper au mauvais endroit, c'est-à-dire après le premier mot. Et comme il n'est pas très malin, il va croire que le nom de famille correspond à la valeur de pi !

Il faudrait en fait pouvoir récupérer toute la ligne plutôt que juste le premier mot. Et si je vous le propose, c'est qu'il y a une solution pour le faire !
Il faut utiliser la fonction getline(). Nous verrons plus loin ce que sont exactement les fonctions, mais pour l'instant voyons comment faire dans ce cas particulier.

Il faut remplacer la ligne cin >> nomUtilisateur; par un getline().

Code : C++ - Lecture d'une ligne complète

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Quel est votre nom ?" << endl;
    string nomUtilisateur("Sans nom");           //On crée une case mémoire pour contenir une chaine de caractères
    getline(cin, nomUtilisateur);                //On remplit cette case avec toute la ligne que l'utilisateur a écrite

    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.);                  //On crée une case mémoire pour stocker un nombre réel
    cin >> piUtilisateur;                        //Et on remplit cette case avec ce qu'écrit l'utilisateur
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pi vaut " << piUtilisateur << "." << endl;

    return 0;
}

On retrouve les mêmes éléments qu'auparavant. Il y a cin et il y a le nom de la variable (nomUtilisateur), sauf que cette fois, le tout se trouve entre des parenthèses et séparé par une virgule et pas par des chevrons.

L'ordre des éléments entre les parenthèses est très important. Il faut absolument mettre le cin en premier !

Cette fois le nom ne sera pas tronqué lors de la lecture et notre ami Albert pourra utiliser notre programme sans soucis.

Code : Console - Plus de soucis pour Albert

Quel est votre nom ?
Albert Einstein
Combien vaut pi ?
3.14
Vous vous appelez Albert Einstein et vous pensez que pi vaut 3.14.

Demander d'abord la valeur de pi

Si l'on utilise d'abord cin >> puis getline(), par exemple en demandant d'abord la valeur de $\pi$ avant de demander le nom, le code ne marche pas. L'ordinateur ne demande pas son nom à l'utilisateur et affiche n'importe quoi.
Pour palier ce problème, il faut ajouter la ligne cin.ignore() après l'utilisation des chevrons.

Code : C++

#include <iostream>
#include <string>
using namespace std;

int main()
{
    cout << "Combien vaut pi ?" << endl;
    double piUtilisateur(-1.);                  //On crée une case mémoire pour stocker un nombre réel
    cin >> piUtilisateur;                        //Et on remplit cette case avec ce qu'écrit l'utilisateur

    cin.ignore();

    cout << "Quel est votre nom ?" << endl;
    string nomUtilisateur("Sans nom");           //On crée une case mémoire pour contenir une chaine de caractères
    getline(cin, nomUtilisateur);                //On remplit cette case avec toute la ligne que l'utilisateur a écrite
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pi vaut " << piUtilisateur << "." << endl;

    return 0;
}

Avec ça, plus de soucis.

Quand on mélange l'utilisation des chevrons et de getline(), il faut toujours faire cin.ignore() après la ligne cin>>a. C'est une règle à apprendre. :soleil:

Voyons maintenant ce que l'on peut faire avec des variables. Par exemple, additionner deux nombres.

Retour en haut

Modifier des variables

Changer le contenu d'une variable

Je vous ai expliqué dans l'introduction de ce chapitre que la mémoire de l'ordinateur ressemblait dans sa manière de fonctionner à celle d'une calculatrice. Ce n'est pas la seule similitude. On peut évidemment effectuer des opérations sur un ordinateur. Et cela se fait en utilisant des variables.

Commençons par voir comment changer le contenu d'une variable. On utilise le symbole = pour effectuer un changement de valeur. Si j'ai une variable de type int dont je veux modifier le contenu, j'écris le nom de ma variable, suivi d'un = et finalement la nouvelle valeur. C'est ce qu'on appelle l'affectation d'une variable.

Code : C++ - Affectation d'une valeur

1
2
3

int unNombre(0);  //Je crée une case mémoire nommée 'unNombre' et qui contient le nombre 0.

unNombre = 5;   //Je mets 5 dans la case mémoire 'unNombre'.

On peut aussi directement affecter le contenu d'une variable à une autre.

Code : C++ - Affectation d'une variable à une autre

1
2
3

int a(4), b(5); //Déclaration de deux variables.

a = b; //Affectation de la valeur de 'b' à 'a'.

Que se passe-t-il exactement ?

Quand il arrive à la ligne 3 du code précédent, l'ordinateur va lire le contenu de la case mémoire nommée b, soit le nombre $5$ . Il va ensuite ouvrir la case dont le nom est a et il y écrit la valeur $5$ en remplaçant le $4$ qui s'y trouvait. Voyons ça avec un schéma.

On peut d'ailleurs afficher le contenu des deux variables pour vérifier.

Code : C++ - Test de l'affectation d'une variable à une autre

#include <iostream>
using namespace std;

int main()
{
    int a(4), b(5); //Déclaration de deux variables.

    cout << "a vaut : " << a << " et b vaut : " << b << endl;

    cout << "Affectation !"<< endl;
    a = b; //Affectation de la valeur de 'b' à 'a'.

    cout << "a vaut : " << a << " et b vaut : " << b << endl;

    return 0;
}

Avez-vous testé ? Non ? N'oubliez pas qu'il est important de tester les codes proposés pour bien comprendre. Bon, comme je suis gentil, je vous donne le résultat.

Code : Console

a vaut : 4 et b vaut : 5 
Affectation !
a vaut : 5 et b vaut : 5

Exactement ce que je vous avais prédit.

La valeur de b n'a pas changé ! Il est important de se rappeler que lors d'une affectation, seule la variable à gauche du symbole = est modifiée.
Cela ne veut pas dire que les deux variables sont égales ! Juste que le contenu de celle de droite est copié dans celle de gauche.

C'est un bon début, mais on est encore loin d'une calculatrice. Il nous manque ...

... les opérations !

Une vraie calculatrice de base !

Commençons avec l'opération la plus simple, l'addition bien sûr. Et je pense que je ne vais pas trop vous surprendre en vous disant qu'on utilise le symbole +.

C'est vraiment très simple à faire :

Code : C++ - Votre première addition

1
2
3

int a(5), b(8), resultat(0);

resultat = a + b; //Et hop une addition pour la route!

Comme c'est votre première opération, je vous décris ce qui se passe précisément. A la ligne 1, le programme crée trois cases dans la mémoire, nommées a, b et resultat. Il remplit également ces cases avec les valeurs $5$ , $8$ et $0$ respectivement. Tout ça, on commence à connaître.

On arrive ensuite à la ligne 3. L'ordinateur voit qu'il va devoir modifier le contenu de la variable resultat. Il regarde alors ce qu'il y a de l'autre côté du = et il trouve qu'il va devoir faire la somme du contenu de ce qui se trouve dans les cases mémoire a et b. Il regarde alors le contenu de a et de b sans le modifier, effectue le calcul et écrit la somme dans la variable resultat. Tout ça en un éclair. Pour calculer, l'ordinateur est un vrai champion.

On peut même vérifier que ça fonctionne si vous voulez.

Code : C++ - Vérification

#include <iostream>
using namespace std;

int main()  
{
  int resultat(0), a(5), b(8);

  resultat = a + b;

  cout << "5 + 8 = " << resultat << endl;
  return 0;
}

Et sur votre écran vous devriez voir :

Code : Console

5 + 8 = 13

Et ce n'est pas tout, il existe encore quatre autres opérations. Je vous ai mis un résumé des possibilités dans un petit tableau récapitulatif.

Opération	Symbole	Exemple
Addition	+	resultat = a + b;
Soustraction	-	resultat = a - b;
Multiplication	*	resultat = a * b;
Division	/	resultat = a / b;
Modulo	%	resultat = a % b;

Mais, qu'est-ce que le modulo ? Je n'ai pas vu ça à l'école.

Je suis sûr que si, mais pas forcément sous ce nom là. Il s'agit en fait du reste de la division entière. Par exemple, si vous ressortez vos cahiers d'école vous devriez retrouver des calculs tels que $13$ divisé par $3$ .
Comme $13$ n'est pas un multiple de $3$ , il faut déduire quelque chose pour en obtenir un. C'est ce "quelque chose" qu'on appelle le reste de la division. Avec notre exemple, on peut écrire $13 = 4*3+1$ . L'opérateur modulo calcule ce reste de la division. Peut-être que vous en aurez besoin un jour.

Cet opérateur n'existe que pour les nombres entiers !

A partir des opérations de base, on peut tout à fait écrire des expressions mathématiques plus complexes qui nécessitent plusieurs variables. On peut également utiliser des parenthèses si nécessaire.

Code : C++

1 2	int a(2), b(4), c(5), d; //Quelques variables d = ((a+b) * c ) - c; //Un calcul compliqué !

La seule limite est votre imagination. Toute expression valide en math, l'est aussi en C++. :magicien:

Retour en haut

Les constantes

Je vous ai présenté comment modifier des variables. J'espère que vous avez bien compris ! Parce qu'on va faire le contraire, en quelque sorte. Je vais vous montrer comment déclarer des variables non modifiables. o_O

En termes techniques, on parle de constantes. Ça fait beaucoup de termes techniques pour un seul chapitre, mais je vous promets que dans la suite, ça va se calmer.

Euh, mais à quoi ça peut bien servir des variables non modifiables ?

Ah, je savais que vous alliez poser cette question. Je vous ai donc préparé une réponse aux petits oignons.

Prenons le futur jeu vidéo révolutionnaire que vous allez créer. Comme vous êtes très fort, je pense qu'il y aura plusieurs niveaux, disons 10. Et bien ce nombre de niveaux ne va jamais changer durant l'exécution du programme. Entre le moment où l'utilisateur a lancé le jeu et le moment où il l'a quitté, il y a eu en permanence 10 niveaux dans votre jeu. Ce nombre est constant. En C++, on pourrait donc créer une variable nombreNiveaux qui serait une constante.

Ce n'est bien sûr pas le seul exemple. Pensez à une calculatrice, elle aura besoin de la constante $\pi$ ou bien à un jeu où les personnages tombent, il faudra utiliser la constante d'accélération de la pesanteur $g=9.81$ , etc.
Ces valeurs ne vont jamais changer. $\pi$ vaudra toujours $3.14$ et l'accélération sur Terre est partout identique. Ce sont des constantes.

On peut même ajouter que ce sont des constantes dont on connaît la valeur lors de la rédaction du code source.

Mais ce n'est pas tout. Il existe aussi des variables dont la valeur ne change jamais mais dont on ne connait pas la valeur à l'avance. o_O

Prenons le résultat d'une opération dans une calculatrice. Une fois que le calcul est effectué, le résultat ne change plus. La variable qui contient le résultat est donc une constante.

Voyons donc comment déclarer une telle variable.

Déclarer une constante

C'est très simple. On déclare une variable normale et on ajoute le mot-clé const entre le type et le nom.

Code : C++ - Une constante

1	int const nombreNiveaux(10);

Et ça marche bien sûr avec tous les types de variables.

Code : C++

1
2
3

string const motDePasse("wAsTZsaswQ");  //Le mot de passe secret
double const pi(3.14);
unsigned int const pointsDeVieMaximum(100); //Le nombre maximal de points de vie

Je pourrais encore continuer longtemps, mais je pense que vous avez saisi le principe. Vous n'êtes pas des futurs génies de l'informatique pour rien.

Déclarez toujours const tout ce qui est possible. Cela permet d'éviter des erreurs d'inattention lorsque l'on programme mais peut aussi aider le compilateur à créer un programme plus efficace.

Vous verrez, on reparlera des constantes dans les chapitres suivants. En attendant, préparez-vous pour votre premier exercice. :pirate:

Retour en haut

Un premier exercice

Je crois qu'on a enfin toutes les clés en main pour réaliser votre premier vrai programme. Dans l'exemple précédent, le programme effectuait l'addition de deux nombres fixés à l'avance. Il serait bien mieux de demander à l'utilisateur quels nombres il veut additionner ! Voilà donc le sujet de notre premier exercice. Demander deux nombres à l'utilisateur, calculer la somme de ces deux nombres et finalement afficher le résultat. :euh:

Rassurez-vous, je vais vous aider, mais je vous invite à essayer par vous-même avant de regarder la solution. C'est le meilleur moyen d'apprendre.

Dans un premier temps, il faut toujours réfléchir aux variables qu'il va falloir utiliser dans le code.

De quoi avons-nous besoin ici ?

Il nous faut une variable pour stocker le premier nombre entré par l'utilisateur et une autre pour stocker le deuxième. En se basant sur l'exemple précédent, on peut simplement appeler ces deux cases mémoires a et b.
Finalement, il faut se poser la question du type de nos variables. Nous voulons faire des calculs, il nous faut donc prendre int, unsigned int ou double selon les nombres que l'on veut utiliser. Je vote pour double, afin de pouvoir utiliser des nombres à virgule.

On peut donc déjà écrire un bout de notre programme, c'est-à-dire la structure de base et la déclaration des variables.

Code : C++

#include <iostream>
using namespace std;

int main()
{
   double a(0), b(0); //Déclaration des variables utiles

   //...
   return 0;
}

La prochaine étape consiste à demander des nombres à l'utilisateur. Je pense que vous vous en souvenez encore, cela se fait grâce à cin >>. On peut donc aller plus loin et écrire :

Code : C++

#include <iostream>
using namespace std;

int main()
{
   double a(0), b(0); //Déclaration des variables utiles

   cout << "Bienvenue dans le programme d'addition a+b !" << endl;

   cout << "Donnez une valeur pour a : ";    //Demande du premier nombre
   cin >> a;

   cout << "Donnez une valeur pour b : ";    //Demande du deuxième nombre
   cin >> b;

   //...

   return 0;
}

Il ne nous reste plus qu'à effectuer l'addition et afficher le résultat. Il nous faut donc une variable. Comme le résultat du calcul ne va pas changer, nous pouvons (et même devons) déclarer cette variable comme une constante.
Nous allons remplir cette constante, que j'appelle resultat, avec le résultat du calcul.
Finalement, pour effectuer l'addition, c'est bien sûr le + qu'il va falloir écrire.

Code : C++ - Correction du premier exercice

#include <iostream>
using namespace std;

int main()
{
   double a(0), b(0); //Déclaration des variables utiles

   cout << "Bienvenue dans le programme d'addition a+b !" << endl;

   cout << "Donnez une valeur pour a : ";    //Demande du premier nombre
   cin >> a;

   cout << "Donnez une valeur pour b : ";    //Demande du deuxième nombre
   cin >> b;

   double const resultat(a + b);   //On effectue l'opération

   cout << a << " + " << b << " = " << resultat << endl; //On affiche le résultat

   return 0;
}

Mmmh, ça a l'air rudement bien tout ça ! Compilons et testons pour voir.

Code : Console

Bienvenue dans le programme d'addition a+b !
Donnez une valeur pour a : 123.784
Donnez une valeur pour b : 51.765
123.784 + 51.765 = 175.549

Magnifique ! Exactement ce qui était prévu !

Bon, j'ai assez travaillé. A vous maintenant de programmer. Je vous propose de vous entrainer en modifiant cet exercice. Voici quelques idées:

Calculer le produit de a et b plutôt que leur somme.
Faire une opération plus complexe comme $a*b + c$ .
Demander deux nombres entiers et calculer leur quotient et le reste de la division.

Bon courage et amusez-vous bien !

Retour en haut

Les raccourcis

Après cet exercice, vous savez manipuler toutes les opérations de base. C'est peut-être surprenant pour vous, mais il n'en existe pas d'autres ! o_O

Avec ces 5 opérations, on peut tout faire, même des jeux vidéo comme ceux présentés dans le chapitre d'introduction.

Il existe quand même quelques variantes qui, j'en suis sûr, vont vous plaire.

L'incrémentation

Une des opérations les plus courantes en informatique c'est ajouter 1 à une variable. Pensez par exemple aux cas suivants :

Passer du niveau 4 au niveau 5 de votre jeu.
Augmenter le nombre de vie du personnage.
Ajouter un joueur à la partie.
etc.

Cette opération est tellement courante qu'elle a un nom spécial. On parle d'incrémentation. Avec vos connaissances actuelles, vous savez déjà comment incrémenter une variable.

Code : C++

1
2
3

int nombreJoueur(4); //Il y a 4 joueurs dans la partie
nombreJoueur = nombreJoueur + 1; //On en ajoute un
//A partir d'ici, il y a 5 joueurs

Bien ! Mais comme je vous l'ai dit, les informaticiens sont des fainéants et la 2^e ligne de ce code est un peu trop longue à écrire. Les créateurs du C++ ont donc inventé une notation spéciale pour ajouter 1 à une variable. Voici comment.

Code : C++

1
2
3

int nombreJoueur(4); //Il y a 4 joueurs dans la partie
++nombreJoueur;
//A partir d'ici, il y a 5 joueurs

On utilise le symbole ++. On écrit ++ suivi du nom de la variable et finalement on met le point-virgule habituel. Ce code a exactement le même effet que le précédent. Il est juste plus court à écrire.

On peut également écrire nombreJoueur++. C'est-à-dire, placer l'opérateur ++ après le nom de la variable. On appelle ça la post-incrémentation à l'opposé de la pré-incrémentation lorsque l'on place le ++ avant le nom de la variable.

Vous trouvez peut-être ça ridicule, mais je suis sûr que vous allez rapidement adorer ce genre de choses !

Cette astuce est tellement utilisée qu'elle est même présente dans le nom du langage ! Oui, oui, C++ veut en quelque sorte dire "C incrémenté", ou en meilleur français, "C amélioré". Ils sont fous ces informaticiens. :-°

La décrémentation

La décrémentation est l'opération inverse. Soustraire 1 à une variable.

La version sans raccourci s'écrit comme ceci.

Code : C++

1
2
3

int nombreJoueur(4); //Il y a 4 joueurs dans la partie
nombreJoueur = nombreJoueur - 1; //On en enlève un
//A partir d'ici, il y a 3 joueurs

Je suis presque sûr que vous connaissez la version courte. On utilise ++ pour ajouter 1, c'est donc -- qu'il faut utiliser pour soustraire 1.

Code : C++

1
2
3

int nombreJoueur(4); //Il y a 4 joueurs dans la partie
--nombreJoueur; //On en enlève un
//A partir d'ici, il y a 3 joueurs

A nouveau, la syntaxe inversée est possible. On peut donc écrire nombreJoueur-- à la place de --nombreJoueur.

Simple, non ? :soleil:

Les autres opérations

Bon. Ajouter ou enlever 1, c'est bien, mais c'est pas non plus suffisant pour tout faire. Il existe des raccourcis pour toutes les opérations de base.

Si l'on souhaite diviser une variable par 3, on devrait écrire en version longue :

Code : C++

1
2
3

double nombre(456); 
nombre = nombre / 3;
//A partir d'ici, nombre vaut 456/3 = 152

La version courte utilise le symbole /= pour obtenir exactement le même résultat.

Code : C++

1
2
3

double nombre(456); 
nombre /= 3;
//A partir d'ici, nombre vaut 456/3 = 152

Il existe des raccourcis pour les 5 opérations de base, c'est-à-dire, +=, -=, *=, /= et %=.
Je suis sûr que vous n'allez plus pouvoir vous en passer. Les essayer, c'est les adopter.

Je vous propose un petit exemple pour la route.

Code : C++ - Utilisation des versions raccourcies des opérateurs

#include <iostream>
using namespace std;

int main()
{
   double nombre(5.3);
   nombre += 4.2;       //nombre vaut maintenant 9.5
   nombre *= 2.;        //nombre vaut maintenant 19
   nombre -= 1.;        //nombre vaut maintenant 18
   nombre /= 3.;        //nombre vaut maintenant 6
   return 0;
}

Ces opérations sont utiles quand il faut ajouter ou soustraire autre chose que 1.

Retour en haut

Encore plus de maths !

Vous en voulez encore ? Ah je vois, vous n'êtes pas satisfait de votre calculatrice. C'est vrai qu'elle est encore un peu pauvre, elle ne connaît que les opérations de base. Pas vraiment génial pour la super-super-calculatrice qu'est votre ordinateur.

Ne partez pas ! J'ai mieux à vous proposer.

L'en-tête cmath

Pour avoir accès à plus de fonctions mathématiques, il faut ajouter une ligne en haut de votre programme, comme lorsque l'on désire utiliser des variables de type string. Il faut ajouter

Code : C++ - Ligne à ajouter pour les fonctions mathématiques

1	#include <cmath>

Jusque là, c'est très simple. Et dans cmath il y a "math", ce qui devrait vous réjouir. On est sur la bonne voie.

Je vais vous présenter comment utiliser quelques fonctions mathématiques en C++. Il se peut très bien que vous ne sachiez pas ce que sont ces fonctions. Ce n'est pas grave, elles ne vous seront pas utiles dans la suite du cours. Vous saurez ce qu'elles représentent quand vous aurez fait un peu plus de maths.

Commençons avec une fonction très souvent utilisée, la racine carrée. En anglais, racine carrée se dit square root et en abrégé on écrit parfois sqrt. :euh:

Comme le C++ utilise l'anglais, c'est ce mot là qu'il va falloir retenir et utiliser.

Pour utiliser une fonction mathématique, on écrit le nom de la fonction, suivi de la valeur à calculer entre parenthèses. On utilise alors l'affectation pour stocker le résultat dans une variable.

Code : C++

1	resultat = fonction(valeur);

C'est comme en math quand on écrit $y = f(x)$ . Il faut juste se souvenir du nom compliqué des fonctions. Pour la racine carrée, cela donnerait resultat = sqrt(valeur);.

N'oubliez pas le point-virgule à la fin de la ligne !

Prenons un exemple complet, je pense que vous allez comprendre rapidement le principe.

Code : C++ - La racine carrée

#include <iostream>
#include <cmath>  //Ne pas oublier cette ligne 
using namespace std;

int main()
{
    double const nombre(16);       //Le nombre dont on veut la racine
                                   //Comme sa valeur ne changera pas on met 'const'
    double resultat;               //Une case mémoire pour stocker le résultat

    resultat = sqrt(nombre);  //On effectue le calcul !

    cout << "La racine de " << nombre << " est " << resultat << endl;

    return 0;
}

Voyons ce que ça donne.

Code : Console

La racine de 16 est 4

Wow ! Votre ordinateur calcule correctement. Mais je ne pense pas que vous en doutiez.

Voyons s'il y a d'autres fonctions à disposition.

Quelques autres fonctions présentes dans cmath

Comme il y a beaucoup de fonctions, je vous propose de tout mettre dans un tableau.

Nom de la fonction	Symbole mathématique	Nom de la fonction en C++	Mini-exemple
Racine carrée	$\sqrt{x}$	sqrt()	resultat = sqrt(valeur);
Sinus	$\sin(x)$	sin()	resultat = sin(valeur);
Cosinus	$\cos(x)$	cos()	resultat = cos(valeur);
Tangente	$\tan(x)$	tan()	resultat = tan(valeur);
Exponentielle	$e^x$	exp()	resultat = exp(valeur);
Logarithme népérien	$\ln{x}$	log()	resultat = log(valeur);
Logarithme en base 10	$\log_{10}{x}$	log10()	resultat = log10(valeur);
Valeur absolue	$\|x\|$	fabs()	resultat = fabs(valeur);
Arrondi vers le bas	$\lfloor x \rfloor$	floor()	resultat = floor(valeur);
Arrondi vers le haut	$\lceil x \rceil$	ceil()	resultat = ceil(valeur);

Les fonctions trigonométriques (sin(), cos(),...) utilisent les radians comme unité d'angle.

Il existe encore beaucoup d'autres fonctions ! Je ne vous ai mis que les principales pour pas qu'on se perde.

On parle de mathématiques, ces fonctions ne sont donc utilisables qu'avec des variables qui représentent des nombres (double, int et unsigned int). Prendre la racine carrée d'une lettre ou calculer le cosinus d'une phrase n'ont de toute façon pas de sens.

Le cas de la fonction puissance

Comme toujours, il y a un cas particulier : la fonction puissance. Comment calculer $4^5$ ? Il faut utiliser la fonction pow() qui est un peu spéciale. Elle prend deux arguments, c'est-à-dire qu'il faut lui mettre deux valeurs entre les parenthèses. Comme pour la fonction getline() dont je vous ai parlé avant.

Si je veux calculer $4^5$ , je vais devoir faire comme ceci.

Code : C++

1
2
3

double const a(4);
double const b(5);
double const resultat = pow(a,b);

Je déclare une variable (constante) pour mettre le $4$ , une autre pour mettre le $5$ et finalement une dernière pour le résultat. Rien de nouveau jusque là. J'utilise la fonction pow() pour effectuer le calcul et j'utilise le symbole = pour initialiser la variable resultat avec la valeur calculée par la fonction.

Nous pouvons donc reprendre l'exercice précédent et remplacer l'addition par notre nouvelle amie, la fonction puissance.

Je vous laisse essayer.

Voici ma version:

Code : C++ - La puissance de pow()

#include <iostream>
#include <cmath>  //Ne pas oublier !
using namespace std;

int main()
{
   double a(0), b(0); //Déclaration des variables utiles

   cout << "Bienvenue dans le programme de calcul de a^b !" << endl;

   cout << "Donnez une valeur pour a : ";    //Demande du premier nombre
   cin >> a;

   cout << "Donnez une valeur pour b : ";    //Demande du deuxième nombre
   cin >> b;

   double const resultat(pow(a, b));   //On effectue l'opération
   //On peut aussi écrire comme avant :
   //double const resultat = pow(a,b);
   //Souvenez-vous des deux formes possibles de l'initialisation d'une variable

   cout << a << " ^ " << b << " = " << resultat << endl; //On affiche le résultat

   return 0;
}

Vous avez fait la même chose ? Parfait !

Vous êtes un futur champion du C++ ! Voyons quand même ce que ça donne.

Code : Console

Bienvenue dans le programme de calcul de a^b !
Donnez une valeur pour a : 4
Donnez une valeur pour b : 5
4 ^ 5 = 1024

J'espère que vous êtes satisfaits avec toutes ces fonctions mathématiques. Je ne sais pas si vous en aurez besoin un jour. Si c'est le cas, vous saurez où en trouver une description.

Retour en haut

Nous voilà au terme de deux gros chapitres sur la mémoire. Dans cette deuxième partie, vous avez appris à modifier les variables grâce au symbole = et à effectuer des opérations mathématiques.

Dans le chapitre suivant, nous allons laisser un peu la mémoire de côté pour nous intéresser à des moyens de modifier le déroulement d'un programme. Une vraie aventure !