Apprenez à programmer en C++

Ajoutez "1" à une variable avec l'incrémentation

Pensez par exemple aux cas suivants :

• passer du niveau 4 au niveau 5 d'un jeu ;

• augmenter le nombre de points de vie du personnage ;

• ajouter un joueur à la partie ;

• etc.

Avec vos connaissances actuelles, vous savez déjà comment incrémenter une variable :

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

Bien ! Mais comme je vous l'ai dit, les informaticiens sont des fainéants, et la deuxième 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 :

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

On peut également écrire nombreJoueur++  , c'est-à-dire placer l'opérateur ++ après le nom de la variable. On appelle cela la post-incrémentation, à l'opposé de la pré-incrémentation qui consiste à placer ++ avant le nom de la variable.

Vous aurez la réponse dans la vidéo suivante :

Retirez "1" à une variable avec la décrémentation

La version sans raccourci s'écrit comme cela :

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

Je suis presque sûr que vous connaissez la version courte ! On utilise -- pour soustraire 1 :

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

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 :

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

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

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

Voici les raccourcis pour les 5 opérations de base : +=  , -=  , *=  , /= 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 :

#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.

Utilisez des fonctions mathématiques

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

La directive à insérer est :

#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.

La fonction racine carrée

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

resultat = fonction(valeur);

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

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

#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 cela donne :

La racine de 16 est 4

Les fonctions principales

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

Il existe beaucoup d'autres fonctions ! Je ne vous ai mis que les principales.

Le cas particulier de la fonction puissance

Comme toujours, il y a un cas particulier : la fonction puissance. Comment calculer $\$\backslash (4^5\backslash )\$$ ?

Si je veux calculer $\$\backslash (4^5\backslash )\$$, je vais devoir faire comme ça :

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

Je déclare une variable (constante) pour mettre le $\$\backslash (4\backslash )\$$, une autre pour stocker le $\$\backslash (5\backslash )\$$, 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 :

#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 : "; //On demande le premier nombre
   cin >> a;

   cout << "Donnez une valeur pour b : "; //On demande le 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 cela donne :

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 satisfait avec toutes ces fonctions mathématiques. Je ne sais pas si vous en aurez besoin un jour mais, si c'est le cas, vous saurez où en trouver une description.

En résumé

• Pour ajouter 1 à la valeur d'une variable, on effectue ce qu'on appelle une incrémentation : variable++;  . L'opération inverse, appelée décrémentation, existe aussi.

• Si vous souhaitez utiliser des fonctions mathématiques plus complexes, comme la racine carrée, il faut inclure l'en-tête <cmath>  dans votre code et faire appel à la fonction comme dans cet exemple :  resultat = sqrt(100);  .

Vous êtes maintenant plus performant qu’une calculatrice ! Néanmoins, la programmation ne s’arrête pas à l’implémentation de calculs complexes, il reste encore plein de concepts à voir, comme les conditions. Allez, on y va !