|
#REDIRECT[[{{Programmation C++/Les types de base et les déclarations]]}}
{{C++ débutant}}
== Le cours du chapitre 2 : la notion de variable ==
__TOC__
<ol>
<li>'''Les variables '''
<br/>
Une variable est un certain endroit en mémoire permettant de stocker une valeur.
En C++, les variables sont typées : elles contiennent soit un entier, un réel, un caractère, … Le type
va exprimer la nature des données contenues dans notre variable.
Les variables portent un nom appelé identificateur.
<br/>
</li>
<li> '''Déclaration des variables'''<br/>
Avant d’utiliser une variable, il faut la déclarer, c'est-à-dire fournir son nom et son type. La déclaration d'une variable est obligatoire. Le nom de la variable s'appelle l'identificateur. Le type de la variable indique la nature des données que va contenir cette variable : un entier, un réel, un caractère,…<br/>
'''Syntaxe de la déclaration :''' type identificateur ;<br/>
'''Exemple :''' int a;
<br/> Cette déclaration déclare une variable a de type int.
<br/>
</li>
== Exercices ==
<li>'''Intérêt de la déclaration'''
<br/> La déclaration des variables permet au programmeur d'indiquer la nature des données qui vont être stockées dans ces variables.
Loin d'être un handicap, la déclaration permet d'éviter de nombreux bogues. Il s'agit d'un garde-fou qui évite au programmeur de nombreuses erreurs.
<br/>
</li>
<li>'''Initialisation des variables '''<br/>
En C++, les variables ont une valeur quelconque après leur déclaration.
Le programmeur doit donc initialiser les variables de son programme, sinon elles contiendront n'importe quoi.
L'oubli d'initialisation d'une variable est un bogue très fréquent.
<br/>
</li>
<li>'''Identificateurs valides'''<br/>
Un identificateur est constitué d'une suite des lettres, de chiffres et _ (underscore).
Un identificateur ne peut pas commencer par un chiffre. Il ne peut pas contenir d'espaces, ni contenir le caractères - (tiret) qui serait interprété comme un moins.
Il doit être explicite c'est-à-dire qu'il doit être en rapport avec ce que contient la variable. Si une variable contient le prix d'un kg de tomates, on va appeler notre identificateur prix_tomate par exemple.
<br/>
</li>
<li>'''Le type int '''<br/>
Il s'agit d'un type de base prédéfini dans le langage C++. Il permet de manipuler des entiers positifs ou négatifs. En général sur 32 bits : les données sont représentées en complément à 2. On peut alors représenter tous les entiers de -2^31 à 2^31-1. Le nombre de bits et le système de représentation des données n'est pas déterminée en C++, ce qui pose de gros problèmes de portabilité des programmes. La manipulation des entiers est exacte sans erreur de calcul !
<br/>
</li>
<li>'''L'affectation '''<br/>
L'affectation permet d'effectuer des calculs et de transférer le résultat dans une certaine variable.
<br/>Syntaxe : identificateur= expression ;
<br/>On commence par évaluer l’expression.
On met le résultat dans la variable identificateur. L'écriture d'une valeur dans une variable remplace la valeur précédente qui est "écrasée". Il doit y avoir une correspondance des types.
<br/>
</li>
<li>''' Exemple 1 : utilisation d'une variable entière'''<br/>
<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a;
a = 80 + 20;
cout << "La valeur de a est : " << a << endl;
return 0;
}
</source>
<ul>
<li>
Dans cet exemple, nous déclarons une variable entière a grâce à la déclaration ''' int a;'''.
</li>
<li>Nous utilisons ensuite l'affectation pour mettre dans a le résultat de l'expression 80+20, c'est-à-dire 100.
</li>
<li>
Nous affichons alors la valeur de a grâce à cout.
</li>
<li>'''Exécution de l'exemple 1 '''<br/>
Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>La valeur de a est 100
</ul>
<br/>
</li>
<li>'''Exemple 2 : incrémentation d'une variable'''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a;
a = 80;
a = a + 1;
cout << "La valeur de a est : " << a << endl;
return 0;
}
</source>
<ul>
<li>L'expression <code>a = a + 1</code>; peut paraitre étrange : elle permet d'augmenter de 1 la valeur de a; a vaut 80 avant l'exécution de cette instruction. a vaut 81 après cette exécution.
</li>
<li>A la place de a=a+1; , on peut également écrire a++;.</li>
<li>'''Exécution de l'exemple 2 '''<br/>
Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>La valeur de a est 81
<br/>
</li>
</ul>
<li>'''Exemple 3 : utilisation de plusieurs variables'''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a, bb = 9, c80;
a = 80;
a++;
bb = bb + a;
c80 = bb - 10;
cout << "La valeur de a est : " << a << endl;
cout << "La valeur de bb est : " << bb << endl;
cout << "La valeur de c80 est : " << c80 << endl;
return 0;
}
</source>
<ul>
<li>
Dans ce nouvel exemple, nous déclarons dans un premier temps 3 variables a,bb et c80.
</li>
<li> Nous effectuons différentes affectations sur ces variables.
</li>
<li>Nous affichons finalement le contenu final de ces variables.
</li>
<li> '''Exécution de l'exemple 3'''
<br/>Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>La valeur de a est 81
<br/>La valeur de bb est 90
<br/>La valeur de c80 est 80
</ul>
<br/>
</li>
<li>'''Différentes opérations '''<br/>
<br/>On peut additionner 2 entiers grâce à l'opérateur +.
<br/>On peut soustraire 2 entiers grâce à l'opérateur -.
<br/>On peut multiplier 2 entiers grâce à l'opérateur *.
<br/>On peut diviser 2 entiers grâce à l'opérateur /. Il y a alors arrondi par troncature du résultat.
<br/>On peut calculer le reste de la division de a par b grâce à l'opérateur %
<br/>
</li>
<li>'''Exemple 4 : utilisation de différentes opérations'''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a = 10, b = 20, c, d, e, f;
c = a + b;
d = a * c;
d = d - 80;
e = d / 7;
f = e % 4;
cout << "La valeur de f est : " << f << endl;
return 0;
}
</source>
Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>La valeur de f est 3
<br/>
</li>
<li>'''cin'''<br/>
Il s’agit du flux d’entrée du programme. Par défaut le flux d'entrée d'un programme en C++ provient du clavier.
En pratique, le cin permet d’envoyer le contenu de ce qui est saisit au clavier dans une variable.<br/>
'''Exemple : '''cin>>i;
<br/>
Lorsque le programme exécute cette instruction, le programme s'arrête et attend que l'utilisateur tape au clavier une valeur entière. Lorsque l'utilisateur appuiera sur entrée , la valeur tapée ira dans la variable i.
<br/>
</li>
<li>'''Exemple 5 : utilisation de cin '''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a;
cout << "Tapez la valeur de a : ";
cin >> a;
a = a + 10;
cout << "La valeur de a est : " << a << endl;
return 0;
}
</source>
<ul>
<li>Dans cet exemple, nous déclarons une variable a.</li>
<li>Nous saisissons ensuite au clavier la valeur de a.</li>
<li>Nous effectuons un calcul sur cette variable.</li>
<li>Nous affichons ensuite la valeur finale de a.</li>
<li>Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>Tapez la valeur de a : '''80'''
<br/>La valeur de a est 90.
<br/>'''Remarque : '''dans cet exemple, l'utilisateur a choisi de taper la valeur 80 pour a.
</li></ul>
<br/>
</li>
<li> '''Le type double '''<br/>
Le type double est un autre type prédéfini du langage C++. Il permet de stocker un réel. En général sur 64 bits, le format de représentation est souvent le format IEEE754. La taille et le système de représentation n'est pas imposé par le langage. Chaque opération peut être entachée d’une minuscule erreur de calcul. La propagation de cette erreur de calcul peut devenir dramatique !
</li>
<br/>
</li>
<li>'''Exemple 6 : utilisation du type double'''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
double a, b, moy;
cout << "Tapez une valeur réelle : ";
cin >> a;
cout << "Tapez une valeur réelle : ";
cin >> b;
moy = (a + b) / 2;
cout << "la moyenne des 2 réels est : " << moy <<endl;
return 0;
}
</source>
<ul>
<li> Dans ce programme, on demande à l'utilisateur de taper successivement 2 valeurs réelles a et b.</li>
<li> On calcule dans la variable moy la moyenne de a et de b.</li>
<li>On affiche ensuite cette moyenne. </li>
<li>'''Exécution de l'exemple 6'''
<br/>Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>Tapez une valeur réelle : '''6.4'''
<br/>Tapez une valeur réelle : '''3.2'''
<br/>La moyenne des 2 réels est : 4.8
<br/>
</li>
</ul>
<br/>
</li>
<li>'''Compatibilité int-double'''<br/>
Les int et les double ne sont pas du tout représentés de la même manière. On peut sans problème copier un int dans un double :
<pre>
int a;
double b;
b=a;
</pre>
Pour mettre un double dans un int, il faut utiliser ce qu'on appelle un cast : on demande explicitement au compilateur de transformer le double en int et il y a alors troncature du double :
<pre>
int a;
double b;
a=(int)b;
</pre>
<br/>
</li>
<li>'''Exemple 7 : mettre un int dans un double'''
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
int a;
double b;
cout << "Tapez une valeur entière : ";
cin >> a;
b = a;
cout << "La valeur de b vaut : " << b <<endl;
return 0;
}
</source>
<ul>
<li>Dans ce programme, on déclare une variable entière (de type int) a et une variable réelle (de type double) b.</li>
<li>On demande à l'utilisateur de saisir la valeur de a.</li>
<li>On met la valeur de a dans la variable b : cette opération s'effectue sans cast.</li>
<li>On affiche ensuite la valeur de b.</li>
<li>'''Exécution de l'exemple 7'''<br/>Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>Tapez une valeur entière : '''18'''
<br/>La valeur de b vaut : 18
</li>
</ul>
<br/>
</li>
<li>'''Exemple 8 : mettre un double dans un int '''<br/>
<source lang="cpp">
#include <iostream>
using namespace std;
int main()
{
double a;
int b;
cout << "Tapez une valeur réelle : ";
cin >> a;
b = (int)a;
cout << "La valeur de b vaut : " << b <<endl;
return 0;
}
</source>
<ul>
<li> Dans ce programme, on déclare une variable réelle (de type double) a et une variable entière (de type int) b.</li>
<li> On demande à l'utilisateur de saisir la valeur de a.</li>
<li> On met la valeur de a dans la variable b : cette opération s'effectue avec un cast. Il y aura troncature de la valeur de a.</li>
<li> On affiche ensuite la valeur de b. </li>
<li>'''Exécution du l'exemple 8'''<br/>
<br/>Lorsqu'on exécute notre programme, il s'affiche à l'écran :
<br/>Tapez une valeur réelle : '''6.78'''
<br/>La valeur de b vaut : 6
</ul>
<br/>
</li>
<li>'''Les commentaires'''<br/>
Il est recommandé d'inclure dans tout programme des commentaires permettant de rendre le programme plus facilement compréhensible.
Un programme doit être compréhensible par un autre programmeur : dans 6 mois, vous aurez oublié comment marche votre programme ou un autre programmeur peut être amené à le modifier.Le compilateur ne tient pas compte de tout ce qui est en commentaire !<br/>
Les commentaires se présentent sous 2 formes:
<ul>
<li>Commentaires sur plusieurs lignes commençant par /* et finissant par */. <br/>/*kkkkkkk JJJJJJJJJJJJJJ*/</li>
<li>Commentaires sur une seule ligne commençant par // <br/>// kkkkkkkkkkkkkkkkkk </li>
</ul>
<br/>
</li>
<li> '''Exemple 9 : les commentaires'''<br/>
<source lang="cpp">
/****************************************
MON PROGRAMME, AUTEUR : MOI
*****************************************/
#include <iostream>
using namespace std;
int main()
{
double a; int b;
// Saisie de la variable a
cout << "Tapez une valeur réelle : ";
cin >> a;
// On met a dans un entier
b = (int)a;
/* Affichage */
cout << "La valeur de b vaut : " << b <<endl;
return 0;
}
</source>
<br/>
</li>
</ol>
== Exercices du chapitre 2 ==
=== EXERCICE 1 ===
Écrire un programme qui demande à l'utilisateur de taper la largeur et la longueur d'un champ et qui en affiche le périmètre et la surface.
| 