Chapitre 02 : Variables, Expressions et Instructions

Introduction au langage C++

Chapitre 2

Variables, Expressions et Instructions

Youssouf EL ALLIOUI, [email protected]

Université Hassan Premier de Settat

Ce cours est disponible en format électronique sur http://fr.slideshare.net/yelallioui/

Objectif de ce chapitre

Notions fondamentales en développement informatique :

Variables, et constantes,

Conversion des types de variables, Expressions et

Instructions.

Opérateurs arithmétiques

Opérateurs d’incrémentation et de décrémentation

Opérateurs d’affectation

Voir comment demander des informations à l'utilisateur et comment les stocker

dans la mémoire :

Lecture depuis la console Afficher la valeur d'une variable

Découvrir la directive cmath.h

Entraînez-vous via

Exercices applicatifs

QCM fourni à la fin de la séance

Les TPs

2016

mailto:[email protected]

http://fr.slideshare.net/yelallioui/

1 | 16

1 Introduction au langage C++ | Chapitre 2 : Variables, Expressions et Instructions

Sommaire

I. Variables __________________________________________________________ 2

II. Constantes ________________________________________________________ 5

III. Références ______________________________________________________ 6

IV. Expressions ______________________________________________________ 7

V. Instructions _______________________________________________________ 14

VI. L'en-tête cmath _________________________________________________ 14

VII. Ce que vous devez retenir ! ________________________________________ 16

Références

Cours de C/C++ [Ouvrage] / aut. Casteyde Christian. - 2001. - Vol. Version 1.40.1 : p. 501.

Programmez avec le langage C++ [Ouvrage] / aut. Mathieu Nebra et Matthieu Schaller. - [s.l.] : le Livre du Zéro, 2015.

2 | 16


I. Variables

I. 1. Qu’est-ce qu’une variable ?

J'imagine que vous avez tous déjà utilisé une calculatrice sur laquelle vous trouvez les

touches M+, M-, MC, etc. qui vous permettent de stocker dans la mémoire de la calculatrice

le résultat intermédiaire d'un calcul et de reprendre ce nombre plus tard.

Le principe de base est le même sur votre ordinateur. Il possède aussi des composants

électroniques qui sont capables de contenir une valeur et de la conserver pendant un

certain temps. Nous n'avons absolument pas besoin de comprendre comment cela marche.

La seule et unique chose que vous ayez besoin de savoir, c'est qu'une variable est une

partie de la mémoire que l'ordinateur nous prête pour y mettre des valeurs pour pouvoir

les réutiliser plus tard.

I. 2. Terminologie

Une variable est caractérisée par :

- Son nom : mot composé de lettres ou chiffres, commençant par une lettre (le

caractère « - » tient lieu de lettre),

- Son type : précisant la nature de cette variable (nombre entier, caractère, objet

etc.),

- Sa valeur : qui peut être modifiée à tout instant.

8

Mémoire

Figure 1 : Exemple de la définition des trois caractéristiques d'une variable

I. 3. Noms de variables

En C++, il y a quelques règles qui régissent les différents noms autorisés ou interdits :

- Les noms de variables sont constitués de lettres, de chiffres et du tiret-bas « _ »

uniquement ;

- Le premier caractère doit être une lettre (majuscule ou minuscule) ;

- On ne peut pas utiliser d'accents ;

- On ne peut pas utiliser d'espaces dans le nom.

Exemple : noms valides & noms invalides

Les noms ageBebe, nom_du_Bebe ou encore NOMBRE_DE_BEBES sont tous des noms

valides. ageBébé et _nom_du_Bebe, en revanche, ne le sont pas.

Valeur

(8) Type

(Entier)

Nom

(ageUtilisateur)

3 | 16


I. 4. Types de base

Après l’identification du nom de la variable, L'ordinateur doit connaitre ce qu'il a dans

cette variable, il faut donc indiquer quel type (nombre, mot, lettre, ou …) d'élément va

contenir la variable que nous aimerions utiliser.

Voici donc la liste des types de variables que l'on peut utiliser en C++ (Tableau 1) :

Nom du type Ce qu'il peut contenir

bool Une valeur parmi deux possibles, vrai (true) ou faux (false).

char Un caractère.

int Un nombre entier.

unsigned int Un nombre entier positif ou nul.

double Un nombre à virgule.

string Une chaîne de caractères, c'est-à-dire un mot ou une phrase.

Tableau 1 : Types de variables en langage C++

Il existe également d'autres types avec d'autres limites mais ils sont utilisés plus

rarement (Tableau 2). A titre d’exemple, il y a des nombres qui sont trop grands pour

un int. Cela ne devrait donc pas vous poser de problème, sachez tout simplement que ces

limites sont bien assez grandes pour la plupart des utilisations courantes.

Type de donnée Signification Taille (en octets) Plage de valeurs acceptée

char Caractère 1 -128 à 127

unsigned char Caractère non

signé

1 0 à 255

short int Entier court 2 -32 768 à 32 767

unsigned short int Entier court non

signé

2 0 à 65 535

int Entier 2 (sur processeur 16 bits)

4 (sur processeur 32 bits)

-32 768 à 32 767

-2 147 483 648 à 2 147 483 647

unsigned int Entier non signé 2 (sur processeur 16 bits)

4 (sur processeur 32 bits)

0 à 65 535

0 à 4 294 967 295

long int Entier long 4 -2 147 483 648 à 2 147 483 647

unsigned long int Entier long non

signé

4 0 à 4 294 967 295

float Flottant (réel) 4 -3.4*10-38 à 3.4*1038

double Flottant double 8 -1.7*10-308 à 1.7*10308

long double Flottant double

long

10 -3.4*10-4932 à 3.4*104932

bool

Booléen Même taille que le type int,

parfois 1 sur quelques

compilateurs

Prend deux valeurs :

true et false mais une conversion

implicite (valant 0 ou 1) est faite par le

compilateur lorsque l'on affecte un

4 | 16


entier (en réalité toute autre valeur que

0 est considérée comme égale à true).

Tableau 2 : Types de variables en langage C++ (version détaillée)

Le mot unsigned qui précède le nom d’un type entier signifie un entier non signé, c’est à

dire toujours un entier toujours positif (Tableau 1 et Tableau 2).

Le mot bool signifie que la variable ne peut prendre que l’une des deux valeurs, true ou

false. On les utilise par exemple pour stocker des informations indiquant si la lumière

est allumée, si l'utilisateur a le droit d'utiliser une fonctionnalité donnée, ou encore si le

mot de passe est correct. Si vous avez besoin de conserver le résultat d'une question de

ce genre, alors pensez type bool.

I. 5. Déclaration des variables

Avant d’utiliser une variable, il faut indiquer à l'ordinateur le type de la variable que nous

voulons, son nom et enfin sa valeur c.-à-d. les trois caractéristique de la variable (revoir I.

2. Terminologie). En effet, en C++, toute variable doit être déclarée avant d’être utilisée.

Une variable se déclare de la façon suivante (Figure 2) :

type Nom_de_la_variable (valeur) ;

Figure 2 : Syntaxe d'initialisation d'une variable en C++

ou bien utiliser la même syntaxe que dans le langage C (Figure 3).

type Nom_de_la_variable = valeur ;

Figure 3 : Syntaxe d'initialisation d'une variable en C++, héritée de C

Soit l’exemple suivant, dans lequel nous déclarons une variable pour stocker l’âge de

l’utilisateur.

1 #include <iostream> 2 using namespace std; 3 int main() 4 { 5 string nomUtilisateur("Albert Einstein"); 6 int ageUtilisateur(16); 7 int nombreAmis(432); //Le nombre d'amis de l'utilisateur 8 double pi(3.14159); 9 bool estMonAmi(true); //Cet utilisateur est-il mon ami ? 10 char lettre('a'); 11 return 0; 12 }

Il y a trois choses importantes à remarquer concernant cet exemple :

- les variables de type bool ne peuvent avoir pour valeur que true ou false, c'est

donc une de ces deux valeurs qu'il faut mettre entre les parenthèses.

- pour le type char, il faut mettre la lettre souhaitée entre apostrophes. Il faut

écrire char lettre('a'); et pas char lettre(a);.

5 | 16


- Pour le type string,

o il faut ajouter une petite ligne au début de votre programme pour indiquer

au compilateur que nous souhaitons utiliser des strings. Sans cela, il

n'inclurait pas les outils nécessaires à leur gestion. La ligne à ajouter

est #include <string>.

o Un peu comme pour le char, il faut mettre la chaine de caractères entre

guillemets et non pas entre des apostrophes

Si vous avez plusieurs variables du même type à déclarer, vous pouvez le faire sur une

seule ligne en les séparant par une virgule (,). Voici comment :

5 float x(2.33), y(21.6);// déclare deux réels x, y 6 int a(2),b(4),c(-1); //On déclare trois cases mémoires nommées a, b et c et

qui contiennent respectivement les valeurs 2, 4 et -1

7 string prenom("Albert"), nom("Einstein"); //On déclare deux cases pouvant contenir des chaînes de caractères

I. 6. Déclaration sans initialisation

Il arrive parfois que l'on ne sache pas quelle valeur donner à une variable lors de sa

déclaration. C++ nous permet alors d'effectuer uniquement l'allocation de la mémoire sans

l'initialisation de la variable. Pour cela, il suffit d'indiquer le type et le nom de la variable

sans spécifier de valeur (Figure 4).

type Nom_de_la_variable = valeur ;

Figure 4 : Déclaration d'une variable sans initialisation

Un exemple de cela est le suivant :

1 #include <iostream> 2 #include <string> 3 using namespace std; 4 int main() 5 { 6 string nomJoueur; 7 int nombreJoueurs; 8 bool aGagne; //Le joueur a-t-il gagné ? 9 return 0; 10 }

II. Constantes Contrairement aux variables les constantes ne peuvent pas être initialisées après leur

déclaration et leur valeur ne peut pas être modifiée après initialisation. Elles doivent être

déclarées avec le mot clé const et obligatoirement initialisées dès sa définition.

Voyons donc comment déclarer une telle constante (Figure 5).

const <type> <NomConstante> = <valeur>;

Figure 5 : Syntaxe de la déclaration d'une constante en C++

6 | 16


Cela marche bien sûr avec tous les types de variables. Voici un exemple :

6 //exemple de constante caractère 7 const char c ('A'); 8 //exemple de constante entière 9 const int i (2016); 10 //exemple de constante rèel 11 const double PI (3.14); 12 //exemple de constante chaine de caractères 13 string const motDePasse("wAsTZsaswQ");

III. Références Dans la vie quotidienne, on peut mettre plusieurs étiquettes sur un objet donné. Disant

des synonymes comme c’est le cas pour le mot ordinateur qu’est computer qu’est PC. Vous

dites ordinateur ou computer ou PC ça revient au même objet !

En C++, c'est la même chose, on peut coller plusieurs étiquettes à la même case mémoire

(ou variable). On obtient alors un deuxième moyen d'y accéder. On parle parfois d'alias,

mais le mot correct en C++ est référence.

Pour déclarer une référence sur une variable, on utilise une esperluette (&). Voyons cela

avec un petit exemple.

6 int ageUtilisateur(16); //Déclaration d'une variable. 7 int& maVariable(ageUtilisateur); //Déclaration d'une référence nommée

maVariable qui est accrochée à la variable ageUtilisateur

On peut schématiser ce code comme suit (Figure 6) :

8

Mémoire

Figure 6 : déclaration d'une référence sur une variable

On dit que maVariablefait référence à ageUtilisateur.

Pratiquement, On peut afficher l'âge de l'utilisateur soit via le nom de la variable soit

via une référence sur cette variable.

1 #include <iostream> 2 using namespace std; 3 int main() 4 { 5 int ageUtilisateur(18); //Une variable pour contenir l'âge de

l'utilisateur 6 7 int& maReference(ageUtilisateur); //Et une référence sur la variable

'ageUtilisateur' 8 //On peut utiliser à partir d'ici 9 //'ageUtilisateur' ou 'maReference' indistinctement

ageUtilisateur maVariable

7 | 16


10 //Puisque ce sont deux étiquettes de la même case en mémoire 11 cout << "Vous avez " << ageUtilisateur << " ans. (via variable)" <<

endl; 12 //On affiche, de la manière habituelle 13 cout << "Vous avez " << maReference << " ans. (via reference)" << endl; 14 //Et on affiche en utilisant la référence 15 return 0; 16 }

Ce qui donne évidemment le résultat escompté.

Une fois qu'elle a été déclarée, on peut manipuler la référence comme si on manipulait la

variable elle-même. Il n'y a aucune différence entre les deux. Mais à quoi est-ce que cela

peut bien servir ?

Pour l'instant, cela vous paraît très abstrait et inutile ? Il faut juste savoir que c'est un

des éléments importants du C++ qui apparaîtra à de très nombreuses reprises dans ce

cours. Il est donc essentiel de se familiariser avec la notion avant de devoir l'utiliser dans

des cas plus compliqués.

IV. Expressions

II. 1. Définition

En combinant des noms de variables, des opérateurs, des parenthèses et des appels de

fonctions (nous allons voir les fonctions dans le chapitre 4), on obtient des expressions.

Une règle simple à retenir :

En C++, on appelle expression tout ce qui a une valeur

II. 2. Opérateurs arithmétiques

Opération Symbole Exemple

Addition + resultat = a + b; Si a=5 et b=2 resultat = 7

Soustaction - resultat = a - b; Si a=5 et b=2 resultat = 3

Multiplication * resultat = a * b; Si a=5 et b=2 resultat = 10

Division / resultat = a / b; Si a=5 et b=2 resultat = 2.5

Modulo % resultat = a % b; Si a=5 et b=2 resultat = 1

8 | 16


Le Modulo représente le reste de la division entière. Cet opérateur n'existe que pour les

nombres entiers !

Dans les expressions, les règles de priorité sont les règles usuelles des mathématiciens.

Par exemple, l’expression 5 + 3 * 2 a pour valeur 11 et non 16. En cas de doute, il ne faut

pas hésiter à mettre des parenthèses.

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

II. 3. Opérateurs d’incrémentation et de décrémentation

Opérateur d’incrémentation (++)

En pratique, nous retrouvons souvent des affectations comme : i = i + 1. Pensez par

exemple aux cas suivants :

- Passer du niveau 4 au niveau 5 d’une application de jeu

- Incrémenter le nombre des inscrits ou bien le nombre de téléchargement de notre

application, …

Les créateurs du C++ ont inventé un opérateur d’incrémentation raccourcie pour ajouter

1 à une variable. Il s’agit de l’opérateur ++. Voici comment.

6 //Notre application est téléchargée 100 fois 7 int nombreDeTelechargement(100); 8 ++nombreDeTelechargement; 9 //à partir d'ici, le nombre de téléchargement est 101

Opérateur de décrémentation (--)

La décrémentation est l'opération inverse, soustraire 1 à une variable. Il s’agit donc de

l’opérateur --.

Autres opérateurs

Opérateur Signification Exemple += ajouter à a += 2 équivalent à a = a + 2 -= diminuer de a -= 2 équivalent à a = a - 2 *= multiplier par a *= 2 équivalent à a = a * 2

/= diviser par a /= 2 équivalent à a = a / 2 %= modulo a %= 2 équivalent à a = a % 2

II. 4. Opérateurs d’affectation

La forme générale de l’expression d’affectation est la suivante :

variable = expression

Fonctionnement :

9 | 16


1) L’expression est d’abord évaluée ; cette valeur donne la valeur de l’expression

d’affectation

2) Effet de bord : la variable reçoit ensuite cette valeur

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

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

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

1 int a(4), b(5); //Déclaration de deux variables 2 3 a = b; //Affectation de la valeur de 'b' à 'a'

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

1 #include <iostream> 2 using namespace std; 3 4 int main() 5 { 6 int a(4), b(5); //Déclaration de deux variables 7 8 cout << "a vaut : " << a << " et b vaut : " << b << endl; 9 10 cout << "Affectation !" << endl; 11 a = b; //Affectation de la valeur de 'b' à 'a'. 12 13 cout << "a vaut : " << a << " et b vaut : " << b << endl; 14 15 return 0;

Le résultat de l’exécution de ce programme est le suivant :

II. 5. Conversion de type

L’expression d’affectation peut provoquer une conversion de type. Par exemple, supposons

la déclaration de deux variables i de type entier et x de type réel :

1 int i; 2 float x;

Alors, si i vaut 3, l’expression x = i donne à x la valeur 3.0 (conversion entier → réel).

Inversement, si x vaut 4.21, l’expression i = x donne à i la valeur 4, partie entière de x

(conversions réel → entier).

Voici un exemple justifiant ce que je viens d’expliquer :

10 | 16


1 #include <iostream> 2 using namespace std; 3 int main() 4 { 5 int i; 6 double x; 7 i = 3; 8 x = i; 9 cout << "conversion entier vers reel :" << endl; 10 cout << "i = " << i << endl; 11 cout << "x = " << x << endl; 12 x = 4.21; 13 i = x; 14 cout << "conversion reel vers entier :" << endl; 15 cout << "x = " << x << endl; 16 cout << "i = " << i << endl; 17 return 0; 18 }

Le résultat obtenu après exécution est le suivant :

On peut également provoquer une conversion de type grâce à l’opérateur () (type casting).

Avec x comme ci-dessus, l’expression (int)x est de type int et sa valeur est la partie

entière de x. Nous allons voir cette astuce en détail dans les TPs.

II. 6. Opérateurs d’entrées-sorties

Ce sont les opérateurs << et >>, utilisés en conjonction avec des objets prédéfinis cout

et cin déclarés dans <iostream.h> (ne pas oublier la directive #include en début de

fichier).

Forme pour afficher la valeur d’une expression :

cout << expression // affichage à l’écran de la valeur de

expression

Forme pour la lecture d’une valeur depuis la console :

cin >> variable //lecture au clavier de la valeur de variable

Voyons ce que cela donne avec ce premier exemple.

1 #include <iostream> 2 using namespace std;

11 | 16


3 4 int main() 5 { 6 cout << "Quel age avez-vous ?" << endl; 7 8 int ageUtilisateur(0); //On prepare une case mémoire pour stocker un

entier 9 10 cin >> ageUtilisateur; //On fait entrer un nombre dans cette case 11 12 cout << "Vous avez " << ageUtilisateur << " ans !" << endl; //Et on

l'affiche 13 14 return 0; 15 }

Si vous testez ce programme. Voici ce que cela donne avec mon âge :

Pour bien comprendre une astuce qui concerne les variables de type string dans ce

contexte, je vous invite à tester le programme suivant pour bien comprendre en détail ce

qui se passe.

1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() 6 { 7 cout << "Quel est votre prenom ?" << endl; 8 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour

contenir une chaine de caractères 9 cin >> nomUtilisateur; //On remplit cette case avec ce qu'écrit

l'utilisateur 10 11 cout << "Combien vaut pi ?" << endl; 12 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un

nombre réel 13 cin >> piUtilisateur; //Et on remplit cette case avec ce qu'écrit

l'utilisateur 14 15 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que

pi vaut " << piUtilisateur << "." << endl; 16 17 return 0; 18 }

12 | 16


Regardons ce que cela donne !

Vous voyez que l'ordinateur n'a rien demandé pour la variable pi et le nom de famille a

disparu !

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 les string, 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 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 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() 6 { 7 cout << "Quel est votre nom ?" << endl; 8 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour

contenir une chaine de caractères 9 getline(cin, nomUtilisateur); //On remplit cette case avec toute la

ligne que l'utilisateur a écrit 10 11 cout << "Combien vaut pi ?" << endl; 12 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un


l'utilisateur 14 15 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que

pi vaut " << piUtilisateur << "." << endl;

13 | 16


16 17 return 0;

18 }

Cette fois le nom ne sera pas tronqué lors de la lecture.

Mais quand même il reste un petit problème ! Si on utilise d'abord cin

>> puis getline(), 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. Vous pouvez essayer ça !

Pour pallier ce problème, il faut ajouter la ligne cin.ignore() après l'utilisation des

chevrons. En effet, Quand on mélange l'utilisation des chevrons et de getline(), il faut

toujours placer l'instruction cin.ignore() après la ligne cin >> a. C'est une règle à

apprendre.

1 #include <iostream> 2 #include <string> 3 using namespace std; 4 5 int main() 6 { 7 cout << "Combien vaut pi ?" << endl; 8 double piUtilisateur(-1.); //On crée une case mémoire pour stocker un


l'utilisateur 10 11 cin.ignore(); 12 13 cout << "Quel est votre nom ?" << endl; 14 string nomUtilisateur("Sans nom"); //On crée une case mémoire pour

contenir une chaine de caractères 15 getline(cin, nomUtilisateur); //On remplit cette case avec toute la

ligne que l'utilisateur a écrit 16 17 cout << "Vous vous appelez " << nomUtilisateur << " et vous pensez que

pi vaut " << piUtilisateur << "." << endl; 18 19 return 0;

20 }

14 | 16


V. Instructions

Les instructions sont généralement identifiées par le point-virgule. C’est ce caractère qui

marque la fin d’une instruction. Il existe deux types d’instructions, qui permettent de

réaliser des opérations variées. Il y a l’instruction-expression et l’instruction-bloc.

III. 1. Instruction-expression

Elle a en générale la forme suivante :

< expression > ;

Les instructions les plus courantes sont sans doute les instructions qui effectuent des

opérations, c’est-à-dire les instructions qui contiennent des expressions utilisant des

opérateurs d’affectation, arithmétique, ou autres.

III. 2. Instruction-bloc

Ce type d’instruction a la forme suivante :

{

< Déclarations et expressions >

}

Il consiste à regrouper plusieurs expressions dans un seul bloc. Ce bloc d’instructions est

considéré comme une instruction unique. Il est donc inutile de mettre un point-virgule

pour marquer l’instruction, puisque le bloc lui-même est une instruction.

Exemple :

4 { 5 int i; 6 double x; 7 i = 3; 8 x = i / 2; 18 }

VI. L'en-tête cmath

Pour avoir accès à plus de fonctions mathématiques, il suffit d'ajouter une ligne en tête

de votre programme.

1 #include <cmath>

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

Nom de la fonction Symbole Fonction Mini-exemple

puissance Pow (x, y) Pow() resultat = pow(valeur1, valeur2);

Racine carrée Sqrt(x)

sqrt() resultat = sqrt(valeur);

1 http://www.cplusplus.com/reference/cmath/

15 | 16


Sinus sin(x)

sin() resultat = sin(valeur);

Cosinus cos(x)

cos() resultat = cos(valeur);

Tangente tan(x)

tan() resultat = tan(valeur);

Exponentielle ex

exp() resultat = exp(valeur);

Logarithme népérien lnx

log() resultat = log(valeur);

Logarithme en base 10 log10x

log10() resultat = log10(valeur);

Valeur absolue |x|

fabs() resultat = fabs(valeur);

Les fonctions trigonométriques (sin(), cos(),… ) utilisent les radians comme unité

d'angles.

Je crois qu'on a enfin toutes les clés en main pour réaliser notre premier vrai

programme. Il s’agit d’un programme qui utilise la fonction pow() pour effectuer le calcul

de ab. Il serait bien mieux de demander à l'utilisateur les valeurs de a et de b !

Voici ma version :

1 #include <iostream> 2 #include <cmath> //Ne pas oublier ! 3 using namespace std; 4 5 int main() 6 { 7 double a(0), b(0); //Déclaration des variables utiles 8 9 cout << "Bienvenue dans le programme de calcul de a^b !" << endl; 10 11 cout << "Donnez une valeur pour a : "; //On demande le premier nombre 12 cin >> a; 13 14 cout << "Donnez une valeur pour b : "; //On demande le deuxième nombre 15 cin >> b; 16 17 double const resultat(pow(a, b)); //On effectue l'opération 18 //On peut aussi écrire comme avant : 19 //double const resultat = pow(a,b); 20 //Souvenez-vous des deux formes possibles 21 //De l'initialisation d'une variable 22 23 cout << a << " ^ " << b << " = " << resultat << endl; 24 //On affiche le résultat 25 26 return 0; 27 }

Voici le résultat que cela donne.

16 | 16


VII. Ce que vous devez retenir ! Une variable est une information stockée en mémoire.

il existe différents types de variables en fonction de la nature de l'information à

stocker : int, char, bool…

Une variable doit être déclarée avant qu’elle soit utilisée.

La valeur d'une variable peut être affichée à tout moment avec cout.

Les références sont des étiquettes qui permettent d'appeler une variable par un

autre nom.

Pour demander à l'utilisateur de saisir une information au clavier, on utilise cin

>> uneVariable;. La valeur saisie sera stockée dans la variable uneVariable.

Il ne faut pas confondre le sens des chevrons cout << et cin >>.

On peut faire toutes sortes d'opérations mathématiques de base en C++ : addition,

soustraction, multiplication… Exemple : x = 2 * (a + b) / 3;

Les constantes sont des variables qu'on ne peut pas modifier une fois qu'elles ont

été créées. On utilise le mot const pour 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 adéquate comme dans cet exemple : resultat = sqrt(100);

Education

Chapitre 02 : Variables, Expressions et Instructions