17 Pointeurs et tableaux
A la section 4, nous avons vu comment définir des tableaux avec
le type vector. Il existe une autre manière, plus basique (on les
appelera tableaux simples), pour manipuler des tableaux :
Syntaxe : type nom[taille];
définit un tableau d'éléments de type type et de taille taille (les
indices vont de 0 à taille-1). La taille doit être une constante.
L'élément d'indice i est désigné par nom[i]. Par exemple:
int Tab[100];
double M[10];
On peut définir des tableaux à plusieurs dimension, par exemple : int
A[10][50];
Il n'est pas possible de récupérer la taille de ces tableaux : il n'existe
pas de fonction size(). Mais (contrairement aux vector)
on peut les initialiser lors de leur définition :
double t[5] = {1.34, 2.21, 3.0, 4.34, 5.78};
char ch[3] = {'a','l','v'};
int t[4][3] = { {0,1,2}, {3,4,5}, {6,7,8}, {9,10,11}};
De plus, lorsqu'on définit un tableau par l'instruction ``MaClasse
Tab[N];'', le constructeur sans argument est appelé sur les N
cases du tableau. Ceci n'est pas vrai pour les types élémentaires : il faut
explicitement initialiser les éléments des tableaux de int,
double ...
Tableaux = pointeurs.
Dans la définition ``int Tab[10]'', le terme Tab désigne
en fait l'adresse de la première case du tableau, c'est-à-dire
``&Tab[0]'' et le type de Tab est ``const int *'',
Tab est donc un pointeur (constant) sur un entier.
Qu'est-ce que Tab[i] ? Tab[i] représente la i-ème case
de Tab, c'est à dire (*(Tab+i)) : le contenu (*) de la
i-ème case après l'adresse Tab. Notez que la taille d'une case
dépend du type 11 (par ex. une fraction prend
plus de place en mémoire qu'un entier); néanmoins le compilateur,
connaissant le type de Tab, sait ce que représente le décalage de
i cases. Considérons les quelques lignes ci-dessus :
//============================
int T[10];
int * p;
p = &T[4];
p[0] = 100; // équivaut à T[4] = 100
p[1] = 200; // équivaut à T[5] = 100
//============================
Les équivalences mentionnées sont dues au fait que ``p[i] = *(p+i)''
et donc ``p[i] = *(t+4+i)''.
Tableaux et fonctions.
Passer un tableau (simple) en paramètre d'une fonction revient à passer
l'adresse de la première case, et donc les tableaux simples sont toujours
passés par référence : si T est un paramètre formel correspondant
à un tableau, modifier T[i] modifiera le ieme élément du
paramètre réel (un tableau) correspondant.
Pour déclarer un paramètre T de type tableau (par ex. d'entiers), on
utilise la notation: int T[]. La taille (si nécessaire) doit être
passée en tant que telle avec un autre paramètre. Par exemple: void
Tri(int T[],int taille)
D'autres chaînes de caractères.
Le type string n'est pas un type élémentaire de C++. En ``C'' et
en ``C++'' il existe, à la base, une notion rudimentaire de chaîne de
caractères : une chaîne de caractères est un tableau (simple) de caractères
se terminant par le caractère spécial '\0'. Par exemple,
char T[8] = "exemple";
définit et initialise le tableau T avec T[0]= 'e', T[1]='x', ..., T[7]='\ 0'. Voir (avec la commande man) les fonctions strcpy, strcmp et autres pour la
manipulation des chaînes de caractères. Bref, il est préférable d'utiliser
string mais sachez que d'autres solutions existent...