Une variable est un objet repéré par son nom, pouvant contenir
des données, qui pourront être modifiées lors de l'exécution du programme.
Les variables en langage C++ sont typées, c'est-à-dire que les données
contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées à une
adresse mémoire et occupent un nombre d'octets dépendant du type de donnée stockée.
En langage C++, les noms de variables peuvent être aussi long que l'on désire, toutefois
le compilateur ne tiendra compte que des 32 premiers caractères.
De plus, elles doivent répondre à certains critères:
- un nom de variable doit commencer par une lettre (majuscule ou minuscule) ou un "_" (pas par un chiffre)
- un nom de variables peut comporter des lettres, des chiffres et le caractère _ (les espaces
ne sont pas autorisés!)
- Les noms de variables ne peuvent pas être les noms suivants (qui sont des noms réservés):
- asm auto
- break
- case catch char class const continue
- default delete do double
- else enum extern
- friend float for
- goto
- if inline int
- long
- new
- operator
- private protected public
- register return
- short signed, sizeof, static, struct, switch
- template this throw try typedef
- union unsigned
- virtual void volatile
- while
Nom de variable correct |
Nom de variable incorrect |
Raison |
Variable | Nom de Variable | comporte des espaces |
Nom_De_Variable | 123Nom_De_Variable | commence par un chiffre |
nom_de_variable | toto@mailcity.com | caractère spécial @ |
nom_de_variable_123 | Nom-de-variable | signe - interdit |
_707 | transient | nom réservé |
|
Les noms de variables sont sensibles à la casse (le langage C++ fait la différence entre
un nom en majuscule et un nom en minuscules), il faut donc veiller à
utiliser des noms comportant la même casse!
|
Pour pouvoir utiliser une variable, il faut la définir, c'est-à-dire lui
donner un nom, mais surtout un type de donnée à stocker afin qu'un
espace mémoire conforme au type de donnée qu'elle contient lui soit réservé.
Une variable se déclare de la façon suivante:
type Nom_de_la_variable;
ou bien s'il y a plusieurs variables du même type:
type Nom_de_la_variable1, Nom_de_la_variable2, ...;
|
- Le langage C++ impose que les variables soient impérativement déclarées
- Le langage C++ permet de définir une variable à n'importe quel endroit du code, afin
de le rendre plus lisible
|
Pour stocker une donnée dans une variable que l'on a initialisée, il faut
faire une affectation, c'est-à-dire préciser la donnée qui va
être stockée à l'emplacement mémoire qui a été
réservé lors de l'initialisation.
Pour cela on utilise l'opérateur d'affectation "=" :
Nom_de_la_variable = donnée;
Pour stocker le caractère B dans la variable que l'on a appelée Caractere,
il faudra écrire:
Caractere = 'B';
Ce qui signifie stocker la valeur ASCII de "B" dans la variable nommée "Caractere".
Il est bien évident qu'il faut avoir préalablement déclaré la variable en lui affectant
le type char:
char Caractere;
La déclaration d'une variable ne fait que "réserver" un emplacement
mémoire où stocker la variable. Tant que l'on ne lui a pas affecté une
donnée celle-ci contient ce qui se trouvait précédemment à cet emplacement,
que l'on appelle garbage (en français: détritus).
On peut donc affecter une valeur initiale à la variable lors de sa déclaration, on parle
alors d'initialisation:
type Nom_de_la_variable = donnee;
Par exemple:
float Toto = 125.36;
Selon l'endroit où on déclare une variable, celle-ci pourra être accessible (visible) de partout
dans le code ou bien que dans une portion confinée de celui-ci (à l'intérieur d'une fonction par exemple), on parle de portée
(ou visibilité) d'une variable.
Lorsqu'une variable est déclarée dans le code même, c'est-à-dire à l'extérieur de toute fonction ou de
tout bloc d'instruction,
elle est accessible de partout dans le code (n'importe quelle fonction du programme peut faire appel à cette variable). On parle
alors de variable globale
Lorsque l'on déclare une variable à l'intérieur d'un bloc d'instructions (entre des accolades), sa portée
se confine à l'intérieur du bloc dans lequel elle est déclarée.
- Une variable déclarée au début du code, c'est-à-dire avant tout bloc de donnée, sera globale, on pourra alors les utiliser à partir de n'importe quel bloc d'instruction
- Une variable déclarée à l'intérieur d'un bloc d'instructions (dans une fonction ou une boucle par exemple) aura une portée limitée à ce seul bloc d'instruction, c'est-à-dire qu'elle est inutilisable ailleurs,
on parle alors de variable locale
En C++, il existe un opérateur, appelé opérateur de résolution de portée, qui permet d'accèder à
des variables globales plutôt qu'à des variables locales, lorsqu'il en existe portant le même nom. Cet opérateur se note ::.
Imaginons que l'on définisse plusieurs variables portant le même nom dans des blocs différents:
int i = 3;
void main(){
int i = 12;
::i = i + ::i;
}
L'opérateur de résolution de portée placé devant le nom de la variable
indique qu'il s'agit de la variable locale. Ainsi, l'instruction ::i = i + ::i; permet
d'ajouter à la variable globale i (celle située en dehors de la fonction main())
la valeur de la variable locale i.
D'une manière générale il est tout de même préférable de donner
des noms différents aux variables locales et globales...
Une constante est une variable dont la valeur est inchangeable lors de l'exécution
d'un programme. En langage C, les constantes sont définies grâce à la
directive du préprocesseur #define, qui permet de remplacer toutes les occurrences
du mot qui le suit par la valeur immédiatement derrière elle. Par exemple la directive suivante
remplacera toutes les chaines de caractères "_Pi" par la valeur 3.1415927 ::
#define _Pi 3.1415927
Toutefois, avec cette méthode les constantes ne sont pas typées, c'est pourquoi
le C++ rajoute le mot réservé const, qui permet de définir
une constante typée, qui ne pourra pas être modifiée pendant toute la durée
d'exécution du programme. Il est ainsi nécessaire d'initialiser la constante dès
sa définition:
const int A = 26;
const float Pi = 3.14159
|