Tableaux et pointeurs en C ++ - le nom du tableau des mannequins

Le nom du tableau est un pointeur vers le tableau lui-même. Le tableau est une séquence de variables stockée en mémoire. Le nom du tableau pointe vers le premier élément.

Voici une question intéressante sur les pointeurs: Pouvez-vous avoir un en-tête de fonction, tel que la ligne suivante, et juste utiliser sizeof pour déterminer combien d'éléments sont dans le tableau? Si c'est le cas, cette fonction n'aurait pas besoin que l'appelant spécifie la taille du tableau.

int AddUp (Nombres int []) {

Considérez cette fonction présente dans l'exemple Array01 et main () qu'il appelle:

vide ProcessArray (int Numbers []) { cout << "à l'intérieur de la fonction: Taille en octets est" << sizeof (Numbers) << endl;} int main (int argc, char * argv []) {int MyNumbers [] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; cout << "fonction extérieure: La taille en octets est"; cout << sizeof (MyNumbers) << endl; ProcessArray (MyNumbers); return 0;}

Lorsque vous exécutez cette application, voici ce que vous voyez:

Fonction externe: La taille en octets est 40 Fonction interne: La taille en octets est 4

En dehors de la fonction, le code sait que la taille du tableau est de 40 octets. Mais pourquoi le code pense-t-il que la taille est 4 après qu'il soit dans le tableau? La raison en est que, même s'il semble que vous transmettez un tableau, vous passez réellement un pointeur à un tableau. La taille du pointeur est juste 4, et c'est ce que la ligne de cout final imprime.

La déclaration des tableaux a une légère idiosyncrasie. Lorsque vous déclarez un tableau en donnant un nombre défini d'éléments, tels que

int MyNumbers [5];

le compilateur sait que vous avez un tableau, et l'opérateur sizeof vous donne la taille du tableau entier. Le nom du tableau, alors, est à la fois un pointeur et un tableau! Mais si vous déclarez un en-tête de fonction sans une taille de tableau, comme

vide ProcessArray (Nombres int []) {

le compilateur de traite cela comme une simple pointeur et rien de plus. Cette dernière ligne est, en fait, équivalente à la ligne suivante:

void ProcessArray (int * Numbers) {

Ainsi, à l'intérieur des fonctions déclarées par l'une ou l'autre ligne, les deux lignes suivantes sont : Chiffres [3] = 10; * (Nombres + 3) = 10;

Cette équivalence signifie que si vous utilisez une déclaration extern sur un tableau, tel que

extern int MyNumbers [];

et ensuite prendre la taille de ce tableau, le compilateur sera confus. Voici un exemple: Si vous avez deux fichiers, des nombres. cpp et main. cpp, où les nombres. cpp déclare un tableau et un main. cpp le déclare en externe (comme montré dans l'exemple Array02), vous obtiendrez une erreur de compilation si vous appelez sizeof:

#include using namespace std; extern int MyNumbers []; int main (int argc, char * argv []) {cout << taille de (MyNumbers) << endl; return 0;}

Dans le code:: blocs, le compilateur gcc nous donne cette erreur:

Erreur: application non valide de 'sizeof' à un type incomplet 'int []'

La solution est de mettre la taille du tableau entre parenthèses.Assurez-vous simplement que la taille est la même que dans l'autre fichier de code source! Vous pouvez truquer le compilateur en changeant le nombre, et vous

n'obtiendrez pas une erreur . Mais c'est un mauvais style de programmation et il suffit de demander des erreurs. Bien qu'un

tableau soit simplement une séquence de variables toutes adjacentes en mémoire, le nom d'un tableau n'est en fait qu'un pointeur sur le premier élément du tableau. Vous pouvez utiliser le nom comme pointeur. Cependant, ne le faites que lorsque vous avez vraiment besoin de travailler avec un pointeur. Après tout, vous n'avez vraiment aucune raison d'écrire du code cryptique, comme * (Nombres + 3) = 10;. L'inverse est également vrai. Regardez cette fonction:

void ProcessArray (int * Numbers) {cout << numbers [1] << endl;}

Cette fonction prend un pointeur comme paramètre, mais vous y accédez en tant que tableau. Encore une fois, n'écrivez pas de code comme ceci; Au lieu de cela, vous devriez comprendre

pourquoi un tel code fonctionne . De cette façon, vous acquérez une connaissance plus approfondie des tableaux et de leur mode de vie à l'intérieur de l'ordinateur, et cette connaissance, à son tour, peut vous aider à écrire du code qui fonctionne correctement. Même si le nom du tableau n'est qu'un pointeur, le nom d'un tableau d'entiers n'est pas exactement la même chose qu'un pointeur vers un entier. Découvrez ces lignes de code (trouvées dans l'exemple Array03):

int LotsONumbers [50]; int x; LotsONumbers = & x;

Pointez le pointeur LotsONumbers

sur quelque chose de différent: quelque chose déclaré comme un entier. Le compilateur ne vous laisse pas faire cela; vous obtenez une erreur. Ce ne serait pas le cas si LotsONumbers étaient déclarés int * LotsONumbers; alors ce code fonctionnerait. Mais comme écrit, ce code vous donne une erreur de compilation. Et croyez-le ou non, voici l'erreur de compilation que vous obtenez dans Code:: Blocks: erreur: types incompatibles dans l'affectation de 'int *' à 'int [50]'

Cette erreur implique que le compilateur voit un distinction nette entre les deux types, int * et int []. Néanmoins, le nom du tableau est en effet un pointeur, et vous pouvez l'utiliser comme un seul; vous ne pouvez pas tout faire avec ce que vous pouvez avec un pointeur normal, comme le réaffecter.

Lorsque vous utilisez des tableaux, notez les conseils suivants. Ceux-ci vous aideront à garder vos tableaux sans bug:

Gardez votre code cohérent. Si vous déclarez, par exemple, un pointeur sur un entier, ne le traitez pas comme un tableau.

• Gardez votre code clair et compréhensible. Si vous passez des pointeurs, il est correct de prendre l'adresse du premier élément, comme dans & MyNumbers [0]) si cela rend le code plus clair - bien que ce soit équivalent à MyNumbers.

• Lorsque vous déclarez un tableau, essayez toujours de placer un nombre entre parenthèses, sauf si vous écrivez une fonction qui prend un tableau.

• Lorsque vous utilisez le mot-clé extern pour déclarer un tableau, allez-y et placez la taille du tableau entre parenthèses. Mais soyez cohérent! N'utilisez pas un numéro une fois et un numéro différent une autre fois. Le moyen le plus simple d'être cohérent consiste à utiliser une constante, telle que const int ArraySize = 10; dans un fichier d'en-tête commun, puis utilisez-le dans votre déclaration de tableau: int MyArray [ArraySize];.