Jeux Libres
       
           

» Les Tutoriels » Apprenez à programmer en C++ ! » Une vraie calculatrice

Note : Vous vous apprêtez à lire un tutoriel de M@teo21 et Nanoc initialement publié à cette adresse sous la licence Creative Commons BY-NC-SA 2.0.

Une vraie calculatrice


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.





Chapitre précédent     Sommaire     Chapitre suivant


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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#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 ;) :
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.


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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <string>
using namespace std;
 
int main()
{
   cout << "Quel est votre prenom ?" << endl;
   string nomUtilisateur("Sans nom");           //On cre une case mmoire pour contenir une chaine de caractres
   cin >> nomUtilisateur;                       //On remplit cette case avec ce qu'crit l'utilisateur
 
   cout << "Combien vaut pi ?" << endl;
   double piUtilisateur(-1.);                  //On cre une case mmoire pour stocker un nombre rel
   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.
Quel est votre prenom ?
Albert Einstein
Combien vaut pi ?
3.14
Vous vous appelez Albert et vous pensez que pi vaut 3.14.

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

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().
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include <string>
using namespace std;
 
int main()
{
   cout << "Quel est votre nom ?" << endl;
   string nomUtilisateur("Sans nom");           //On cre une case mmoire pour contenir une chaine de caractres
   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 cre une case mmoire pour stocker un nombre rel
   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. ;)
Quel est votre nom ?
Albert Einstein
Combien vaut pi ?
3.14
Vous vous appelez Albert Einstein et vous pensez que pi vaut 3.14.

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 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.
1
2
3
int unNombre(0);  //Je cre une case mmoire nomme 'unNombre' et qui contient le nombre 0.
 
unNombre = 5;   //Je mets 5 dans la case mmoire 'unNombre'.

On peut aussi directement affecter le contenu d'une variable à une autre.
1
2
3
int a(4), b(5); //Dclaration 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>
using namespace std;
 
int main()
{
   int a(4), b(5); //Dclaration 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.
1
2
3
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 :
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.
1
2
3
4
5
6
7
8
9
10
11
12
#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 :
1
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érationSymboleExemple
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.
1
2
int a(2), b(4), c(5), d; //Quelques variables
d = ((a+b) * c ) - c; //Un calcul complique !

La seule limite est votre imagination. Toute expression valide en math, 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. 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 [math=inline]\pi[/math] 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. [math=inline]\pi[/math] vaudra toujours 3.14 et l'accélération sur Terre est partout identique. Ce sont des constantes. :)

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.
1
int const nombreNiveaux(10);

Et ça marche bien sûr avec tous les types de variables.
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. ;)

Vous verrez, on reparlera des constantes dans les chapitres suivants. 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ê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.
Il nous faut aussi une troisième case pour stocker le résultat du calcul. Appelons cette variable resultat tout simplement.
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.
1
2
3
4
5
6
7
8
9
10
#include <iostream>
using namespace std;
 
int main()
{
  double a(0), b(0), resultat(0); //Declaration 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 :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
using namespace std;
 
int main()
{
  double a(0), b(0), resultat(0); //Declaration 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 deuxieme nombre
  cin >> b;
 
  //...
 
  return 0;
}

Il ne nous reste plus qu'à effectuer l'addition et afficher le résultat. Pour changer la valeur de resultat, il va falloir utiliser le symbole = et pour effectuer l'addition, c'est bien sûr le + qu'il va falloir écrire.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
using namespace std;
 
int main()
{
  double a(0), b(0), resultat(0); //Declaration 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 deuxieme nombre
  cin >> b;
 
  resultat = a + b;   //On effectue l'operation
 
  cout << a << " + " << b << " = " << resultat << endl; //On affiche le resultat
 
  return 0;
}

Mmmh, ça a l'air rudement bien tout ça ! 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é. 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 !


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.
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 2e 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.
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 le nom de la variable, suivi de ++ 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.

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.
1
2
3
int nombreJoueur(4); //Il y a 4 joueurs dans la partie
nombreJoueur = nombreJoueur - 1; //On en enleve 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.
1
2
3
int nombreJoueur(4); //Il y a 4 joueurs dans la partie
nombreJoueur--; //On en enleve un
//A partir d'ici, il y a 3 joueurs

Simple, non ?

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 :
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.
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.
1
2
3
4
5
6
7
8
9
10
11
12
#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 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
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. 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.
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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <cmath>  //Ne pas oublier cette ligne
using namespace std;
 
int main()
{
   double nombre(16);       //Le nombre dont on veut la racine
   double resultat;         //Une case mmoire pour stocker le rsultat
 
   resultat = sqrt(nombre);  //On effectue le calcul !
 
   cout << "La racine de " << nombre << " est " << resultat << endl;
 
   return 0;
}
1
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 fonctionSymbole mathématiqueNom de la fonction en C++Mini-exemple
Racine carrée
[math=inline]\sqrt{x}[/math]
sqrt()resultat = sqrt(valeur);
Sinus
[math=inline]\sin(x)[/math]
sin()resultat = sin(valeur);
Cosinus
[math=inline]\cos(x)[/math]
cos()resultat = cos(valeur);
Tangente
[math=inline]\tan(x)[/math]
tan()resultat = tan(valeur);
Exponentielle
[math=inline]e^x[/math]
exp()resultat = exp(valeur);
Logarithme népérien
[math=inline]\ln{x}[/math]
log()resultat = log(valeur);
Logarithme en base 10
[math=inline]\log_{10}{x}[/math]
log10()resultat = log10(valeur);
Valeur absolue
[math=inline]|x|[/math]
fabs()resultat = fabs(valeur);
Arrondi vers le bas
[math=inline]\lfloor x \rfloor[/math]
floor()resultat = floor(valeur);
Arrondi vers le haut
[math=inline]\lceil x \rceil[/math]
ceil()resultat = ceil(valeur);

Et il y en a encore beaucoup d'autres ! 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 tout façon pas de sens. ;)


Le cas de la fonction puissance




Comme toujours, il y a un cas particulier : la fonction puissance. Comment calculer 45 ? 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 45, je vais devoir faire comme ceci.
1
2
3
4
double a(4);
double b(5);
double resultat;
resultat = pow(a,b);

Je déclare une variable 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 stocker la valeur obtenue dans la variable resultat.

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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <cmath>  //Ne pas oublier !
using namespace std;
 
int main()
{
  double a(0), b(0), resultat(0); //Dclaration 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 deuxime nombre
  cin >> b;
 
  resultat = pow(a, b);   //On effectue l'opration
 
  cout << a << " ^ " << b << " = " << resultat << endl; //On affiche le rsultat
 
  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.
1
2
3
4
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. ;)




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 !



Chapitre précédent     Sommaire     Chapitre suivant



Distribué et adapté par David
Consulté 14070 fois



Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 240 jours 12 heures 24 minutes
Espace libre : 1569 Mo
Dernière sauvegarde : 22/07/2019
Taille de la sauvegarde : 1112 Mo


5357240 pages ont été consultées sur le site !
Dont 2699 pages pendant les 24 dernières heures.

Page générée en 0.587 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2019 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.