Mémoire et variables

Mémoire et variables#

Un ordinateur traite de l'information.

  • Il faut pouvoir la stocker: la mémoire

  • Il faut pouvoir y accéder: les variables

Mémoire#

https://fr.wikipedia.org/wiki/Mémoire_(informatique)

../_images/4mbramvax.jpg
../_images/Memory_module_DDRAM_20-03-2006.jpg
../_images/1200px-Four_MMC_cards_front.jpg
../_images/Floppy_disk_2009_G1.jpg
../_images/Dat_cartridge.jpg
../_images/Lochkarte_Tanzorgel.jpg
../_images/CD_autolev_crop.jpg
../_images/1176px-Laptop-hard-drive-exposed.jpg

Modèle de mémoire basique#

  • Une suite contiguë de 0 et de 1 Les bits (bit), groupés par paquets de huit appelés octets (byte)

  • Pour 1 Go, à raison de un bit par mm, cela ferait 8590 km Plus que Paris-Pékin!

  • Le processeur y accède par adresse

Variables#

Une variable est un espace de stockage nommé où le programme peut mémoriser une donnée; elle possède quatre propriétés:

  • Un nom (ou identificateur (identifier)): Il est choisi par le programmeur

  • Une adresse (address): Où est stockée la variable dans la mémoire

  • Un type qui spécifie:

    • La structure de donnée: comment la valeur est représentée en mémoire
      En particulier combien d'octets sont occupés par la variable

    • La sémantique des opérations

  • Une valeur: Elle peut changer en cours d'exécution du programme

Règles de formation des identificateurs#

Les noms des variables (ainsi que les noms des programmes, constantes, types, procédures et fonctions) sont appelés des identificateurs.

Syntaxe: règles de formation des identificateurs

  • suite de lettres (minuscules 'a'...'z' ou majuscules 'A'...'Z'), de chiffres ('0'...'9') et de caractères de soulignement ('_')

  • premier caractère devant être une lettre

  • longueur bornée

Exemples et contre-exemples d'identificateurs :

  • c14_T0 est un identificateur

  • 14c_T0 n'est pas un identificateur

  • x*y n'est pas un identificateur

Formation des identificateurs : bonnes pratiques#

  • Donnez des noms signifiants aux variables

  • Dans le cas de plusieurs mots, par convention dans le cadre de ce cours on mettra le premier mot en minuscule et les suivants avec une majuscule: maVariable

  • Autre convention possible: ma_variable

  • Mauvais noms : truc, toto, temp, nombre

  • Bons noms courts: i, j, k, x, y, z t, notamment pour coller aux notations usuelles en mathématiques, physique, ...

  • Bons noms longs: notes, moyenneNotes, estNegatif

Modèle mémoire affiné : la pile#

Rappel : Syntaxe : déclaration des variables

type nomvariable;
type nomvariable1, nomvariable2, ...;

🤔 Quelle sémantique?

  • Comment est choisie l'adresse?

  • Comment s'assurer qu'elle n'est pas déjà utilisée?

  • Comment libérer la mémoire quand on n'en a plus besoin?

La pile

Toutes les variables déclarées sont regroupées dans une portion de la mémoire appelée la pile.

On représente la pile sous la forme d'un tableau spécifiant le type, le nom et la valeur des variables actuellement déclarées.

Exemple

Voici une représentation de la pile d'un programme avec trois variables d, l, et i :

┌──────────┬─────┐
│    int i │  4  │
│   long l │  4  │
│ double d │ 1.5 │
└──────────┴─────┘
       Pile

Notes

  • Seuls les valeurs sont stockées dans la mémoire

  • Les indications de nom et de type sont des indications pour le lecteur

  • L'espace réservé pour une variable (nombre d'octets, déterminé par son type) est implicite dans cette représentation.

Remarque

Souvent, lorsque l'on analyse le comportement d'un programme, on ne s'intéresse qu'aux dernières variables déclarées. On utilise alors ... pour représenter les autres variables dont on ne souhaite pas donner les détails :

┌──────────┬─────┐
│    int i │  4  │
│   long l │  4  │
│   ...    │ ... │
└──────────┴─────┘
       Pile

Sémantique : déclaration de variable

Lorsqu'une nouvelle variable est déclarée :

  1. Un espace mémoire de la taille requise est alloué au sommet de la pile

  2. Le contenu initial de cet espace est non spécifié

Exemple

Code:

`int v;`

Avant la déclaration:

┌──────────┬─────┐
│      ... │     │
└──────────┴─────┘
       Pile

Après la déclaration:

┌──────────┬─────┐
│    int v │  ?  │
│      ... │     │
└──────────┴─────┘
       Pile

Portée des variables et sémantique de déallocation

Supposons que des variables soient déclarées dans un bloc. Alors:

  1. ces déclarations ne sont valides que jusqu'à la fin du bloc

  2. lorsque l'exécution sort du bloc, les variables sont désallouées de la pile

Exemple

... {
    ...
    int x;
    int y = 2;
    ...
}

Avant la déclaration:

┌──────────┬─────┐
│      ... │     │
└──────────┴─────┘
       Pile

Après la déclaration de x:

┌──────────┬─────┐
│    int x │  ?  │
│      ... │     │
└──────────┴─────┘
       Pile

Après la déclaration de y et son initialisation à 2:

┌──────────┬─────┐
│    int y │  2  │
│    int x │  ?  │
│      ... │     │
└──────────┴─────┘
       Pile

Après être sorti du bloc:

┌──────────┬─────┐
│      ... │     │
└──────────┴─────┘
       Pile

Initialisation des variables#

Quelle est la valeur de ces variables après leur déclaration?

double d;
long l;
int i;

l

0
type: long

d

0.0000000
type: double

i

0
type: int

  • Certains langages ou compilateurs garantissent que les variables sont initialisées à une valeur par défaut.

  • En C++, pas forcément!

    Typiquement, la valeur de la variable correspond à l'état de la mémoire au moment de sa déclaration

Bonne pratique: systématiquement initialiser les variables au moment de leur déclaration:

int i = 0;
long l = 1024;
double d = 3.14159;
Contenu