Fil d'Ariane
Mis à jour le mardi 25 juillet 2017
  • 50 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

Ce cours existe en livre papier.

Ce cours existe en eBook.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Une vraie calculatrice

Connectez-vous ou inscrivez-vous pour bénéficier de toutes les fonctionnalités de ce cours !

J'ai commencé à vous parler de variables au chapitre précédent en vous présentant la mémoire d'une calculatrice. Un ordinateur étant une super-super-super-calculatrice, on doit pouvoir lui faire faire des calculs et pas uniquement sauvegarder des données. J'espère que cela 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 cela, é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.

Demander des informations à l'utilisateur

Au 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 beaucoup de mots tirés de l'anglais. C'est notamment le cas pour le flux sortantcout, 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. Aveccout, les données sortent du programme, d'où l'élémentout. Le contraire deouten anglais étantin, qui signifie « vers l'intérieur », on utilisecinpour faire entrer des informations dans le programme.cinse 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 decin, il y en a aussi, mais dans l'autre sens (>>).

Voyons ce que cela donne avec un premier exemple.

#include <iostream>
using namespace std;

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

    int ageUtilisateur(0); //On prepare une case mémoire 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 cela donne avec mon âge :

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

Que s'est-il passé exactement ?

Le programme a affiché le texteQuel age avez-vous ?. Jusque-là, rien de bien sorcier. Puis, comme on l'a vu précédemment, à la ligne 8, le programme demande à l'ordinateur une case mémoire pour stocker unintet il baptise cette caseageUtilisateur.
Ensuite, cela 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 la touche Entrée de son clavier, le programme prend ce qui a été écrit et le place dans la case mémoireageUtilisateur à 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 les premiers à écrirecout >>oucin <<, 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 verscoutou depuiscinvers votre variable.

Le mieux est de prendre un petit schéma magique (figure suivante).

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 verscout. Quand on demande une information à l'utilisateur, c'est le contraire, la valeur vient decinet va dans la variable.

Avec cela, 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 cela avec un petit exemple.

#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 contenirune 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'écritl'utilisateur
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pivaut " << 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 vos nom et prénom ? Regardons ce que cela donne.

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 la touche Entrée, l'ordinateur copie ce qui a été écrit par l'utilisateur dans la case mémoire. Mais il s'arrête au premier espace ou retour à la ligne. Quand il s'agit d'un nombre, cela ne pose pas de problème puisqu'il n'y a pas d'espace dans les nombres.
Pour lesstring, la question se pose. Il peut très bien y avoir un espace dans une chaîne de caractères. 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 !

En fait, il faudrait pouvoir récupérer toute la ligne plutôt que seulement le premier mot. Et si je vous le propose, c'est qu'il y a une solution pour le faire !
Il faut utiliser la fonctiongetline(). 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 lignecin >> nomUtilisateur;par ungetline().

#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 toutela ligne que l'utilisateur a écrit

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

    return 0;
}

On retrouve les mêmes éléments qu'auparavant. Il y acinet il y a le nom de la variable (nomUtilisateur) sauf que, cette fois, ces deux éléments se retrouvent encadrés par des parenthèses et séparés par une virgule au lieu des chevrons.

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

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'abordcin >>puisgetline(), par exemple pour demander la valeur de pi avant de demander le nom, le code ne fonctionne pas. L'ordinateur ne demande pas son nom à l'utilisateur et affiche n'importe quoi.
Pour pallier ce problème, il faut ajouter la lignecin.ignore()après l'utilisation des chevrons.

#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 unnombre réel
    cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écritl'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 écrit
     
    cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que pivaut " << piUtilisateur << "." << endl;

    return 0;
}

Avec cela, plus de souci.
Quand on mélange l'utilisation des chevrons et degetline(), il faut toujours placer l'instructioncin.ignore()après la lignecin>>a. C'est une règle à apprendre.

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

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 ressemble, dans sa manière de fonctionner, à celle d'une calculatrice. Ce n'est pas la seule similitude. On peut évidemment effectuer des opérations de calcul sur un ordinateur. Et cela se fait en utilisant des variables.

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

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

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 lit le contenu de la case mémoire nomméeb, soit le nombre $\(5\)$. Il ouvre ensuite la case dont le nom est a et y écrit la valeur $\(5\)$ en remplaçant le $\(4\)$ qui s'y trouvait. Voyons cela avec un schéma (figure suivante).

Affectation d'une variable à une autre

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

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

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

Exactement ce que je vous avais prédit.

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 :

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. À la ligne 1, le programme crée dans la mémoire trois cases, dénomméesa,betresultat. Il remplit également ces cases respectivement avec les valeurs $\(5\)$, $\(8\)$ et $\(0\)$. Tout cela, on commence à connaître.

On arrive ensuite à la ligne 3. L'ordinateur voit qu'il doit modifier le contenu de la variableresultat. Il regarde alors ce qu'il y a de l'autre côté du symbole = et il remarque qu'il doit faire la somme des contenus des cases mémoireaetb. Il regarde alors le contenu deaet desans le modifier, effectue le calcul et écrit la somme dans la variableresultat. Tout cela en un éclair. Pour calculer, l'ordinateur est un vrai champion.

Si vous voulez, on peut même vérifier que cela fonctionne.

#include <iostream>
using namespace std;

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

  resultat = a + b;

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

Sur votre écran vous devriez voir :

5 + 8 = 13

Ce n'est pas tout, il existe encore quatre autres opérations. Je vous ai mis un résumé des possibilités dans un 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 cela à 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\)$ . On obtient un nombre entier dénommé « quotient » (en l'occurrence, il vaut $\(4\)$) mais, comme $\(13\)$ n'est pas un multiple de $\(3\)$, il faut compléter $\(3 \times 4\)$ par quelque chose (ici, 1) pour obtenir exactement $\(13\)$ . C'est ce « quelque chose » qu'on appelle le reste de la division. Avec notre exemple, on peut donc écrire $\(13 = 4 \times 3 + 1\)$ , c'est-à-dire $\(13 = quotient \times 3 + reste\)$. L'opérateur modulo calcule ce reste de la division. Peut-être en aurez-vous besoin un jour.

Une autre opération avec un comportement bizarre est la division, plus particulièrement lorsqu'elle est appliquée à des nombres entiers. En effet, la division d'une variable de typeintpar une autre variable de typeintva retourner un autre nombre entier, ce qui peut poser problème suivant les nombres choisis. Par exemple, en divisant  $\(5\)$  par$\(3\)$ , on obtient$\(1\)$ , ce qui est une version tronquée de la valeur exacte$\(1.66666....\)$ . La division appliquée aux nombres entiers renvoie donc à la partie entière de la réponse. Il est très courant de se faire prendre au piège !

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

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 maths l'est aussi en C++.

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.

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

Euh, mais à quoi peuvent 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 forts, je pense qu'il y aura plusieurs niveaux, disons 10. Eh bien ce nombre de niveaux ne va jamais changer durant l'exécution du programme. Entre le moment où l'utilisateur lance le jeu et le moment où il le quitte, il y a en permanence 10 niveaux dans votre jeu. Ce nombre est constant. En C++, on pourrait donc créer une variablenombreNiveauxqui serait une constante.

Ce n'est, bien sûr, pas le seul exemple. Pensez à une calculatrice, qui aura besoin de la constante $\(\pi\)$, ou bien à un jeu dans lequel les personnages tombent et où il faudra utiliser la constante d'accélération de la pesanteur  $\(g=9.81\)$ (environ), et ainsi de suite.

Ces valeurs ne vont jamais changer.

$\(\pi\)$ vaudra toujours $\(3.14\)$ (environ) 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 connaît pas la valeur à l'avance. 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éconstentre le type et le nom.

int const nombreNiveaux(10);

Cela marche bien sûr avec tous les types de variables.

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 continuer encore longtemps mais je pense que vous avez saisi le principe. Vous n'êtes pas des futurs génies de l'informatique pour rien.

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

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.
Rassurez-vous, je vais vous aider, mais je vous invite à essayer par vous-mêmes 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émoiresaetb.
Ensuite, on doit se poser la question du type des variables. Nous voulons faire des calculs, il nous faut donc opter pour desint,unsigned intoudoubleselon les nombres que nous voulons utiliser. Je vote pourdoubleafin 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.

#include <iostream>
using namespace std;

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

   //…
   return 0;
}

L'étape suivante 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 :

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

   cout << "Donnez une valeur pour b : "; //On demande le 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'appelleresultat, avec le résultat du calcul.
Finalement, pour effectuer l'addition, c'est bien sûr le symbole + qu'il va falloir utiliser.

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

   cout << "Donnez une valeur pour b : "; //On demande le 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, cela a l'air rudement bien tout cela ! Compilons et testons pour voir.

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é. À vous maintenant de programmer. Je vous propose de vous entraîner en modifiant cet exercice. Voici quelques idées:

  • calculer le produit deaetbplutô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 !

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 ! 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 consiste à ajouter « 1 » à une variable. Pensez par exemple aux cas suivants :

  • passer du niveau 4 au niveau 5 de votre jeu ;

  • augmenter le nombre de points de vie du personnage ;

  • ajouter un joueur à la partie ;

  • etc.

Cette opération est tellement courante qu'elle porte un nom spécial. On parle en réalité d'incrémentation. 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. Voici comment.

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

On utilise le symbole ++. On écrit ++ suivi du nom de la variable et on conclut par 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 écrirenombreJoueur++, 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 trouvez peut-être cela ridicule mais je suis sûr que vous allez rapidement adorer ce genre de choses !

La décrémentation

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

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 ajouter 1, c'est donc -- qu'il faut utiliser 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

Simple, non ?

Les autres opérations

Bon. Ajouter ou enlever 1, c'est bien mais ce n'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 :

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

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.

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

Encore plus de maths !

Vous en voulez encore ? Ah je vois, vous n'êtes pas satisfaits 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êtecmath

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 typestring. La directive à insérer est :

#include <cmath>

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

Commençons avec une fonction utilisée très souvent, la racine carrée. En anglais, racine carrée se dit square root et, en abrégé, on écrit parfois sqrt. 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, 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 en math quand on écrit $\(y = f(x)\)$. Il faut juste se souvenir du nom compliqué des fonctions. Pour la racine carrée, cela donneraitresultat = 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

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 danscmath

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

Nom de la fonction

Symbole

Fonction

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 \times \rfloor\]$

floor()

resultat = floor(valeur);

Arrondi vers le haut

$\[\lceil \times \rceil\]$

ceil()

resultat = ceil(valeur);

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

Le cas de la fonction puissance

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

Si je veux calculer $\(4^5\)$, je vais devoir procéder ainsi :

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 stocker le $\(5\)$ et finalement une dernière pour le résultat. Rien de nouveau jusque là. J'utilise la fonctionpow()pour effectuer le calcul et j'utilise le symbole = pour initialiser la variableresultatavec 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 de futurs champions 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 satisfaits 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 demander à l'utilisateur de saisir une information au clavier, on utilisecin >> variable;. La valeur saisie sera stockée dans la variable.

  • Il ne faut pas confondre le sens des chevronscout <<etcin >>.

  • On peut faire toutes sortes d'opérations mathématiques de base en C++ : addition, soustraction, multiplication… Exemple :resultat = a + b;

  • Les constantes sont des variables qu'on ne peut pas modifier une fois qu'elles ont été créées. On utilise le motconstpour les définir.

  • 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);

Exemple de certificat de réussite
Exemple de certificat de réussite