Une instruction finit par un point-virgule. Elle peut servir à déclarer un objet, lui donner une valeur, appeler une fonction, appeler plusieurs fonctions de façon imbriquée, etc. Dire qu'une instruction finit par un point-virgule est sans doute une bonne ébauche de définition de l'instruction...
Un bloc d'instructions est délimité par des accolades. Toute instruction fait naturellement partie d'un bloc à un certain niveau (par exemple elle fait partie d'une boucle ou d'une fonction). Le bloc lui-même peut être considéré comme une grosse instruction. Il n'y a pas besoin d'ajouter un ; après un bloc.
Une variable déclarée à l'intérieur un bloc est automatiquement détruite à la sortie du bloc. On ne peut alors plus la consulter. Si l'on veut que la variable continue d'exister après la fin de ce bloc, il suffit de la déclarer avant ce bloc. Exemple: dans
{ int x = 12; }
on ne peut plus consulter x après la fin du bloc, la variable a disparu de la mémoire. Mais l'on peut faire ainsi:
int y;
{ y = 12; }
int z = y + 1;
puisque dans ce cas la variable y existait déjà avant le bloc.
Dans le cas des tableaux, le problème se pose différemment, car effacer un pointeur ne signifie pas effacer la variable sur laquelle il pointe:
double* q;
{ double* p;
p = new double[2];
p[0] = 2.;
p[1] = 4.5;
q = &(p[0]);
}
double x = q[0] + q[1];
Ici, au sortir du bloc, p a été effacé, c-à-d que la variable p qui contenait l'adresse d'un tableau a été effacée, mais pas le tableau qui lui a toujours pour adresse la valeur qu'avait p. Heureusement, on a sauvé cette adresse dans un autre pointeur, q, ce qui permet d'accéder de nouveau au tableau. Le seul moyen d'effacer un tableau est d'appeler delete[] explicitement:
delete[] q;
ce qui libère le tableau qui a pour adresse la valeur de q.
Attention, si deux pointeurs p et q pointent vers un même tableau et que le tableau est effacé par delete[] p; alors q continue de pointer à la même adresse mais il n'y a plus d'espace alloué à cet endroit-là pour un tableau.
Notons également que l'on peut déclarer localement une variable portant un nom qui existe déjà. Dans ce cas, à l'intérieur du bloc, la variable qui sera considérée sera celle déclarée dans le bloc, et à la sortie du bloc l'ancienne sera à nouveau considérée alors que la variable locale aura disparu. Par exemple:
int a = 3;
int b;
{ int a = 4;
b = a;
}
int c = a;
A la fin de cette série d'instructions, b vaudra 4 tandis que c vaudra 3.