'>

les "Arrays" en C++

Un réseau est un ensemble d'éléments du même type placés dans des emplacements de mémoire contigus qui peuvent être référencés individuellement par addition d'un indice d'un identificateur unique.

Cela signifie que, par exemple, nous pouvons stocker 5 valeurs de type int dans un tableau sans avoir à déclarer 5 variables différentes, chacune avec un identifiant différent. Au lieu de cela, en utilisant un tableau, nous pouvons stocker 5 valeurs différentes du même type, int, par exemple, avec un identifiant unique.

Par exemple, un tableau pour contenir 5 valeurs entières de type int appelé Billy pourrait être représentée comme suit:


où chaque panneau vide représente un élément du tableau, qui dans ce cas sont des valeurs entières de type int. Ces éléments sont numérotés de 0 à 4 dans des réseaux depuis le premier index est toujours 0, indépendamment de sa longueur.

Comme une variable ordinaire, un tableau doit être déclarée avant d'être utilisée. Une déclaration typique pour un tableau en C + + est:

nom du type [éléments];

où type est un type valide (comme int, float ...), le nom est un identifiant valide et le champ des éléments (qui est toujours entre crochets []), indique combien de ces éléments, le tableau doit contenir.

Par conséquent, afin de déclarer un tableau appelé billy que celui indiqué sur le schéma ci-dessus, il est aussi simple que:



   

 int billy [5];



NOTE: Le champ des éléments entre crochets [] qui représente le nombre d'éléments du tableau va tenir, doit être une valeur constante, puisque les tableaux sont des blocs de mémoire non-dynamique dont la taille doit être déterminée avant l'exécution. Afin de créer des tableaux avec une longueur variable mémoire dynamique est nécessaire, ce qui est expliqué plus loin dans ces tutoriaux.

Initialisation de tableaux.
Lors de la déclaration d'un réseau régulier de portée locale (dans une fonction, par exemple), si on ne précise pas autrement, ses éléments ne seront pas initialisés à une valeur par défaut, de sorte que leur contenu sera indéterminée jusqu'à ce que nous conservons une certaine valeur en eux. Les éléments des tableaux globaux et statiques, d'autre part, sont automatiquement initialisés avec leurs valeurs par défaut, qui pour tous les types fondamentaux, cela signifie qu'ils sont remplis de zéros.

Dans les deux cas, local et global, lorsque nous déclarons un tableau, nous avons la possibilité d'affecter des valeurs initiales de chacun de ses éléments en enfermant les valeurs entre accolades {}. Par exemple:



   

 int billy [5] = { 16, 2, 77, 40, 12071 };



Cette déclaration aurait créé un tableau comme celui-ci:


La quantité de valeurs entre accolades {} ne doit pas être plus grand que le nombre d'éléments que nous déclarons pour le tableau entre crochets []. Par exemple, dans l'exemple du tableau billy nous avons déclaré qu'il dispose de 5 éléments et dans la liste des valeurs initiales entre accolades {} nous avons spécifié 5 valeurs, une pour chaque élément.

Lorsque l'initialisation des valeurs est prévue pour un tableau, C + + permet la possibilité de laisser les crochets [] vide. Dans ce cas, le compilateur suppose une taille pour le tableau qui correspond au nombre de valeurs comprises entre accolades {}:



   

 int billy [] = { 16, 2, 77, 40, 12071 };



Après cette déclaration, array billy serait 5 ints longtemps, puisque nous avons prévu 5 valeurs d'initialisation.

Accéder aux valeurs d'un tableau.

En tout point d'un programme dans lequel un tableau est visible, nous pouvons accéder à la valeur de l'un de ses éléments individuellement comme si c'était une variable normale, étant ainsi en mesure de lire et modifier sa valeur. Le format est aussi simple que:

nom [index]

Après les exemples précédents, dans lequel Billy avait 5 éléments et chacun de ces éléments est de type int, le nom que nous pouvons utiliser pour désigner chaque élément est la suivante:


Par exemple, pour stocker la valeur 75 dans le troisième élément de billy, nous pourrions écrire la déclaration suivante:



   

 billy[2] = 75;



et, par exemple, pour passer la valeur du troisième élément de billy à une variable appelée un, nous pourrions écrire:



   

 a = billy[2];



Par conséquent, l'expression billy [2] est à toutes fins utiles comme une variable de type int.

Notez que le troisième élément de Billy Billy est spécifié [2], puisque le premier est billy [0], le second est billy [1], et par conséquent, le troisième est billy [2]. Par cette même raison, son dernier élément est billy [4]. Par conséquent, si nous écrivons billy [5], nous serions accéder à la sixième élément de Billy et dépassant donc la taille du tableau.

En C + +, il est syntaxiquement correct pour dépasser la plage valide d'indices pour un tableau. Cela peut créer des problèmes, puisque l'accès aux éléments hors de portée ne doit pas provoquer d'erreurs de compilation, mais peut provoquer des erreurs d'exécution. La raison pour laquelle cela est autorisé verra plus loin lorsque nous commençons à utiliser des pointeurs.

A ce stade, il est important d'être capable de distinguer clairement entre les deux utilisations crochets [] sont liés aux tableaux. Ils effectuent deux tâches différentes: l'une est de spécifier la taille des tableaux quand ils sont déclarés, et le second est à préciser indices pour les éléments du tableau concrètes. Ne confondez pas ces deux utilisations possibles des crochets [] avec des tableaux.

 1
 2


   

 int billy[5]; // declaration of a new array billy[2] = 75; // access to an element of the array.



Si vous lisez attentivement, vous verrez que le spécificateur de type précède toujours une variable ou un tableau déclaration, alors qu'elle ne précède jamais un accès.

D'autres opérations valides avec des tableaux:

 1
 2
 3
 4


   

 billy[0] = a; billy[a] = 75; b = billy [a+2]; billy[billy[a]] = billy[2] + 5;



 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16


   

 // arrays example #include <iostream> using namespace std; int billy [] = {16, 2, 77, 40, 12071}; int n, result=0; int main () { for ( n=0 ; n<5 ; n++ ) { result += billy[n]; } cout << result; return 0; }

   

  12206



Les tableaux multidimensionnels

Les tableaux multidimensionnels peuvent être décrits comme "des tableaux de tableaux". Par exemple, un réseau bidimensionnel peut être imaginé comme un tableau bidimensionnel composé d'éléments, tous d'un même type de données uniforme.


jimmy représente un réseau bidimensionnel de 3 par 5 éléments de type int. La façon de déclarer ce tableau en C + + serait:



   

 int jimmy [3][5];



et, par exemple, le moyen pour référencer le deuxième élément verticalement et horizontalement dans une quatrième expression devient:



   

 jimmy[1][3]




(Rappelons que les indices de tableau commencent toujours par zéro).

Les tableaux multidimensionnels ne sont pas limités à deux indices (ie, deux dimensions). Ils peuvent contenir autant d'indices que nécessaire. Mais attention! La quantité de mémoire nécessaire pour un tableau rapide augmente à chaque dimension. Par exemple:



   

 char century [100][365][24][60][60];



déclare un tableau avec un élément caractères pour chaque seconde en un siècle, soit plus de 3 milliards de caractères. Donc, cette déclaration ne consommerait plus de 3 Go de mémoire!

Les tableaux multidimensionnels sont juste une abstraction pour les programmeurs, puisque nous pouvons obtenir les mêmes résultats avec un tableau simple juste en mettant un facteur compris entre ses indices:

 1
 2


   

 int jimmy [3][5]; // is equivalent to int jimmy [15]; // (3 * 5 = 15)



Avec la seule différence que, avec des tableaux multidimensionnels le compilateur se souvient de la profondeur de chaque dimension imaginaire pour nous. Prenons comme exemple ces deux morceaux de code, à la fois avec exactement le même résultat. On utilise un tableau à deux dimensions et l'autre on utilise un tableau simple:

tableau multidimensionnel     matrice pseudo-multidimensionnel

 # Define largeur 5
 # Define HAUTEUR 3

 int jimmy [hauteur] [WIDTH];
 int n, m;

 int main ()
 {
   pour (n = 0, n <hauteur; n + +)
     pour (m = 0; m <WIDTH, m + +)
     {
       Jimmy [n] [m] = (n +1) * (m +1);
     }
   retour 0;
 }

   

 # Define largeur 5
 # Define HAUTEUR 3

 int jimmy [HAUTEUR * WIDTH];
 int n, m;

 int main ()
 {
   pour (n = 0, n <hauteur; n + +)
     pour (m = 0; m <WIDTH, m + +)
     {
       jimmy [n * largeur + m] = (n +1) * (m +1);
     }
   retour 0;
 }


Aucun des deux codes sources ci-dessus génère aucune sortie à l'écran, mais les deux valeurs attribuent au bloc de mémoire appelée jimmy de la façon suivante:


Nous avons utilisé "constantes définies" (# define) pour simplifier d'éventuelles modifications futures du programme. Par exemple, dans le cas où nous avons décidé d'agrandir le tableau à une hauteur de 4 au lieu de 3, il pourrait être fait simplement en changeant la ligne:



   

 #define HEIGHT 3


à:



   

 #define HEIGHT 4



sans avoir besoin de faire d'autres modifications au programme.

Les tableaux en tant que paramètres
À un certain moment, nous pouvons avoir besoin de passer un tableau à une fonction en tant que paramètre. En C + +, il n'est pas possible de passer un bloc complet de la mémoire en valeur comme paramètre à une fonction, mais nous sommes autorisés à passer son adresse. En pratique, cela a presque le même effet et c'est une opération beaucoup plus rapide et plus efficace.

Pour accepter des tableaux comme paramètres que la seule chose que nous avons à faire lors de la déclaration de la fonction est de spécifier dans les paramètres du type d'élément du tableau, un identifiant et d'une paire de crochets vides []. Par exemple, la fonction suivante:



   

 void procedure ( int arg[])



accepte un paramètre de type «tableau d'entiers" appelé arg. Pour passer à cette fonction un tableau déclaré ainsi:



   

 int myarray [40];



il suffirait d'écrire un appel comme ceci:



   

 procedure (myarray);



Ici vous avez un exemple complet:

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18


   

 // arrays as parameters #include <iostream> using namespace std; void printarray ( int arg[], int length) { for ( int n=0; n<length; n++) cout << arg[n] << " " ; cout << "\n" ; } int main () { int firstarray[] = {5, 10, 15}; int secondarray[] = {2, 4, 6, 8, 10}; printarray (firstarray,3); printarray (secondarray,5); return 0; }

   

  5 10 15
  2 4 6 8 10



Comme vous pouvez le voir, le premier paramètre (int arg []) accepte n'importe quel tableau dont les éléments sont de type int, quelle que soit sa longueur. Pour cette raison, nous avons inclus un deuxième paramètre qui indique la fonction de la longueur de chaque tableau que nous passons à ce que son premier paramètre. Cela permet à la boucle qui imprime le tableau pour connaître la gamme d'itérer dans le tableau passé sans sortir de gamme.

Dans une déclaration de fonction, il est également possible d'inclure des tableaux multidimensionnels. Le format d'un paramètre de tableau tridimensionnel est:



   

 base_type[][depth][depth]



Par exemple, une fonction avec un tableau multidimensionnel comme argument pourrait être:



   

 void procedure ( int myarray[][3][4])



Notez que les premiers crochets [] sont laissés vides tandis que les suivants précisent tailles pour leurs dimensions respectives. Cela est nécessaire pour que le compilateur pour être en mesure de déterminer la profondeur de chaque dimension supplémentaire.

Les tableaux à la fois simple ou multidimensionnel, passés comme paramètres de la fonction sont une source assez fréquent d'erreurs pour les programmeurs débutants. Je recommande la lecture du chapitre sur les pointeurs pour une meilleure compréhension de la façon dont fonctionnent les tableaux. 
Publié par Drupal Study