Les tableaux sont un sujet extrêmement important en C++. Dans les programmes, ils sont très souvent utilisés et il est nécessaire de bien comprendre ce sujet. Je vais vous faire plaisir tout de suite - comprendre et apprendre à utiliser les tableaux est assez simple même pour un débutant.

Alors, pourquoi avons-nous besoin de tableaux et quels sont-ils ? A présent, vous savez déjà très bien que les données du programme sont stockées dans le fichier . Mais il arrive que le programme doive stocker des centaines (voire plus) de variables du même type de données, et doive également travailler avec elles - attribuer des valeurs, les modifier, etc.

Par exemple, il est nécessaire de stocker des numéros de série de lignes. D'accord - tout le monde aura peur à l'idée que vous deviez créer cinq cents variables int, donner à chacune un nom unique et attribuer une valeur de 1 à 500. (J'ai déjà peur :) Dans ce cas, les tableaux vont tout simplement nous sauver.

Nous notons l'essentiel et passons à un exemple pratique :

• Un tableau en C++ est une collection d'un certain nombre de variables du même type qui ont le même nom. Par exemple, tableau d'entiers ;. Cette entrée signifie que nous avons déclaré un tableau nommé déployer, lequel à contient 3 variables de type entier ;
• les variables de tableau sont appelées éléments ;
• chaque élément a son propre index unique - son numéro de série. En utilisant l'index, nous pouvons nous référer à un élément spécifique. IMPORTANT - l'indexation des éléments du tableau commence à partir de 0 . Donc en tableau tableau int le premier élément a un index 0 , et le dernier est 2 . Pour accéder par exemple à l'élément zéro d'un tableau et changer sa valeur, il faut préciser le nom du tableau et indiquer l'indice de l'élément entre crochets - tableau = 33 .

Prenons un exemple :

Tableaux C++

// dans ce programme, nous créons un tableau avec la taille size, // en utilisant la boucle for, nous entrons des données dans toutes les cellules // du tableau et affichons leur contenu à l'écran #include en utilisant l'espace de noms std ; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //déclaration d'une constante int firstArray; //déclaration d'un tableau avec le nombre d'éléments SIZE pour (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

A la ligne 12 on définit une constante entière TAILLE, qui stockera la taille du tableau (défini par nous, le nombre de ses éléments). A la ligne 13, on déclare un tableau : on indique le type de données qui seront stockées dans les cellules du tableau, on donne un nom et on indique la taille entre crochets.

Il est important que nous ne puissions écrire que des valeurs constantes entières entre crochets. Il faut soit saisir immédiatement un entier entre crochets lors de la déclaration d'un tableau ( int premier tableau ;), ou définissez une constante entière avant la déclaration du tableau et entrez le nom de cette constante entre crochets (comme dans notre exemple).

La deuxième méthode est préférable si, au cours du programme, vous devez accéder plusieurs fois au tableau via une boucle. Cela s'explique par le fait que lorsque l'on déclare un cycle, il est possible de préciser la condition de passage du compteur à la valeur TAILLE .

Imaginez que nous devions changer la taille du tableau de 10 éléments à 200. Dans ce cas, tout ce que nous avons à faire est de changer la valeur d'une constante entière, et ainsi nous insérerons automatiquement de nouvelles valeurs de taille dans le tableau et dans toutes les boucles du programme.

Vous pouvez essayer dans notre exemple d'ajouter n'importe quel autre nombre à la constante TAILLE. Et vous verrez que le programme fonctionnera bien - il créera un tableau avec autant d'éléments que vous spécifiez, entrera les données et l'affichera à l'écran.

Et si le tableau est assez petit, par exemple 5 éléments, vous pouvez l'initialiser immédiatement lors de la déclaration :

Donc l'élément d'indice 0 est premiertableau- la valeur sera attribuée 11 , et le dernier élément du tableau premiertableau- sens 1 5 . Il existe une telle astuce - vous ne pouvez pas spécifier la taille du tableau entre crochets et écrire ceci :

L'entrée précédente est équivalente à celle-ci. Seulement dans le second cas, le compilateur calculera automatiquement la taille du tableau, en fonction de la quantité de données entre accolades.

De plus, lors de l'initialisation initiale des éléments du tableau, lorsque le tableau doit être vidé de "garbage" (données résiduelles d'autres programmes en mémoire), il est préférable d'attribuer immédiatement une valeur à tous les éléments 0 . Il ressemble à ceci :

Il convient de rappeler qu'une telle initialisation n'est possible que pour le remplissage avec des zéros. Si vous devez remplir les éléments du tableau avec d'autres nombres, il est préférable d'utiliser une boucle. En C++11 (la norme de codage), lors de l'utilisation de l'initialisation de liste (initialisation avec des accolades), il est même permis de supprimer le signe = .

Je voudrais montrer une autre méthode d'initialisation lors de la création d'un tableau. Par exemple, pour un tableau de 30 éléments, nous devons entrer des valeurs 33 et 44 uniquement dans les cellules avec un index 0 et 1 respectivement, et remplissez le reste avec des zéros. Ensuite, nous faisons ceci :

ces données seront saisies dans les cellules zéro et première, et le reste prendra automatiquement la valeur 0 .

Vous pouvez organiser le remplissage d'un tableau à l'aide de l'opérateur cin:

pour (int je = 0; je< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> premierTableau[i] ; )

Un tableau est une structure de données représentée comme un groupe de cellules de même type, réunies sous un seul nom. Les tableaux sont utilisés pour traiter de grandes quantités de données du même type. Le nom du tableau est , ce sont des pointeurs que j'expliquerai un peu plus tard. Une cellule de données de tableau individuelle est appelée un élément de tableau. Les éléments de tableau peuvent être n'importe quel type de données. Les tableaux peuvent avoir une ou plusieurs dimensions. En fonction du nombre de dimensions, les tableaux sont divisés en tableaux unidimensionnels, tableaux bidimensionnels, tableaux tridimensionnels, etc. jusqu'à un tableau à n dimensions. Le plus souvent en programmation, des tableaux unidimensionnels et bidimensionnels sont utilisés, nous ne considérerons donc que ces tableaux.

Tableaux unidimensionnels en C++

Un tableau à une dimension est un tableau avec un paramètre caractérisant le nombre d'éléments d'un tableau à une dimension. En fait, un tableau à une dimension est un tableau qui ne peut avoir qu'une ligne et n colonnes. Les colonnes d'un tableau unidimensionnel sont les éléments du tableau. La figure 1 montre la structure d'un tableau entier unidimensionnel un. La taille de ce tableau est de 16 cellules.

Figure 1 - Tableaux en C++

Notez que l'index maximum d'un tableau unidimensionnel un est 15, mais la taille du tableau est de 16 cellules, car la numérotation des cellules du tableau commence toujours à partir de 0. L'index de cellule est un entier non négatif qui peut être utilisé pour accéder à chaque cellule du tableau et y effectuer des actions (cellule ).

//syntaxe pour déclarer un tableau unidimensionnel en C++ : /*type de données*/ /*nom du tableau unidimensionnel*/ ; //un exemple de déclaration d'un tableau unidimensionnel illustré à la figure 1 : int a ;

où, int est un nombre entier ;

A est le nom d'un tableau unidimensionnel ;
16 est la taille d'un tableau unidimensionnel, 16 cellules.

Toujours immédiatement après le nom du tableau, il y a des crochets qui spécifient la taille d'un tableau à une dimension, c'est ce qui distingue un tableau de toutes les autres variables.

//une autre façon de déclarer des tableaux unidimensionnels int mas, a;

Deux tableaux unidimensionnels mas et a sont déclarés avec des tailles 10 et 16, respectivement. De plus, dans cette façon de déclarer, tous les tableaux auront le même type de données, dans notre cas, int .

// les tableaux peuvent être initialisés lorsqu'ils sont déclarés : int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // initialisation d'un tableau unidimensionnel

L'initialisation d'un tableau unidimensionnel s'effectue entre accolades après le signe équivaut à, chaque élément du tableau est séparé du précédent par une virgule.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // initialisation du tableau sans déterminer sa taille.

Dans ce cas, le compilateur déterminera lui-même la taille d'un tableau à une dimension. La taille d'un tableau ne peut être omise que lorsqu'il est initialisé ; lors de la déclaration normale d'un tableau, vous devez spécifier la taille du tableau. Développons un programme simple pour traiter un tableau unidimensionnel.

// array.cpp : définit le point d'entrée de l'application console. #include "stdafx.h" #include << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// code Code :: Blocs

// Code Dev-C++

// array.cpp : définit le point d'entrée de l'application console. #comprendre en utilisant l'espace de noms std ; int main(int argc, char* argv) ( cout<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

À lignes 10 - 11 tableau unidimensionnel d'entiers déclaré et initialisé nommé tableau1 , dont la taille est égale à 16 cellules, c'est-à-dire qu'un tel tableau peut stocker 16 nombres. Tout traitement d'un tableau n'est possible qu'en conjonction avec des boucles. Le cycle à choisir pour le traitement du tableau dépend de vous. Mais il est le mieux adapté à cette tâche. Nous utiliserons la variable counter counter pour faire référence aux éléments du tableau unidimensionnel array1 . Il y a un signe d'inégalité stricte dans la condition de poursuite de la boucle for, puisqu'il n'y a pas de seizième index dans le tableau unidimensionnel array1. Et puisque la numérotation des cellules commence à partir de zéro, il y a 16 éléments dans le tableau.Dans le corps de la boucle for, l'instruction cout imprime les éléments d'un tableau unidimensionnel (voir Figure 2).

Traitement des index massiva élément tableau1 tableau1 5 tableau1 -12 tableau1 -12 tableau1 9 tableau1 10 tableau1 0 tableau1 -9 tableau1 -12 tableau1 -1 tableau1 23 tableau1 65 tableau1 64 tableau1 11 tableau1 43 tableau1 39 tableau1 -15 Appuyez sur n'importe quelle touche pour continuer. . .

Figure 2 - Tableaux en C++

Développons un autre programme pour traiter un tableau unidimensionnel en C++. Le programme doit lire séquentiellement dix chiffres entrés à partir du clavier. Additionnez tous les nombres saisis, affichez le résultat à l'écran.

// array_sum.cpp : définit le point d'entrée de l'application console. #include "stdafx.h" #include << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// code Code :: Blocs

// Code Dev-C++

// array_sum.cpp : définit le point d'entrée de l'application console. #comprendre en utilisant l'espace de noms std ; int main(int argc, char* argv) ( int array1; // déclare un tableau d'entiers cout<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >>tableau1 ; // lit les nombres saisis depuis le clavier cout<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

Avant de traiter un tableau, il doit être déclaré et la taille d'un tableau unidimensionnel est de 10, comme cela est stipulé par la condition du problème. Dans la variable sum, on va accumuler la somme des éléments d'un tableau à une dimension. La première boucle for remplit le tableau unidimensionnel déclaré avec des nombres saisis au clavier, lignes 12 - 13. La variable compteur est utilisée pour accéder séquentiellement aux éléments du tableau unidimensionnel array1 , à partir de l'indice 0 et jusqu'au 9ème inclus. La deuxième boucle for affiche les éléments du tableau, lignes 15 - 16. La troisième boucle for lit séquentiellement les éléments d'un tableau unidimensionnel et les additionne, la somme est accumulée dans la variable somme, lignes 17 - 18. Voir le résultat du programme dans la figure 3.

Entrez elementi massiva : 0 1 2 3 4 5 6 7 8 9 array1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Appuyez sur n'importe quelle touche pour continuer. . .

Figure 3 - Tableaux en C++

Tout d'abord, les 10 nombres ont été entrés séquentiellement, après quoi un tableau unidimensionnel a été affiché et la somme des nombres du tableau a été imprimée.

Tableaux 2D en C++

Jusqu'à présent, nous avons considéré des tableaux à une dimension, qui ne peuvent pas toujours être limités. Supposons que vous ayez besoin de traiter certaines données d'une table. Un tableau a deux caractéristiques : le nombre de lignes et le nombre de colonnes. Également dans un tableau à deux dimensions, en plus du nombre d'éléments de tableau, il existe des caractéristiques telles que le nombre de lignes et le nombre de colonnes d'un tableau à deux dimensions. Autrement dit, visuellement, un tableau à deux dimensions est un tableau normal, avec des lignes et des colonnes. En fait, un tableau à deux dimensions est un tableau à une dimension de tableaux à une dimension. La structure d'un tableau à deux dimensions, nommé a , de taille m par n est illustrée ci-dessous (voir Figure 4).

Figure 4 - Tableaux en C++

où, m est le nombre de lignes d'un tableau à deux dimensions ;
n est le nombre de colonnes du tableau à deux dimensions ;
m * n est le nombre d'éléments du tableau.

// syntaxe pour déclarer un tableau à deux dimensions /*type de données*/ /*nom du tableau*/;

Dans la déclaration d'un tableau à deux dimensions, ainsi que dans la déclaration d'un tableau à une dimension, la première chose à faire est de spécifier :

• Type de données;
• nom du tableau.

Après cela, le nombre de lignes du tableau bidimensionnel est indiqué entre les premiers crochets, le nombre de colonnes du tableau bidimensionnel est indiqué entre les deuxièmes crochets. Un tableau bidimensionnel est visuellement différent d'un tableau unidimensionnel par la seconde paire de crochets. Prenons un exemple de déclaration d'un tableau à deux dimensions. Disons que nous devons déclarer un tableau à deux dimensions, avec le nombre d'éléments égal à 15. Dans ce cas, un tableau à deux dimensions peut avoir trois lignes et cinq colonnes, ou cinq lignes et trois colonnes.

// exemple de déclaration d'un tableau à deux dimensions : int a;

• a - nom du tableau d'entiers
• le nombre entre les premiers crochets indique le nombre de lignes dans le tableau à deux dimensions, dans ce cas 5 ;
• le nombre entre les deuxièmes crochets spécifie le nombre de colonnes dans le tableau à deux dimensions, dans ce cas 3.

// initialisation d'un tableau à deux dimensions : int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, un) );

Ce tableau a 5 lignes, 3 colonnes. après le signe d'affectation, des accolades générales sont placées, à l'intérieur desquelles il y a autant de paires d'accolades qu'il devrait y avoir de lignes dans un tableau à deux dimensions, et ces accolades sont séparées par des virgules. Dans chaque paire d'accolades, écrivez les éléments d'un tableau à deux dimensions séparés par des virgules. Toutes les accolades doivent avoir le même nombre d'éléments. Puisqu'il y a cinq chaînes dans le tableau, il y a aussi cinq paires de crochets internes. Trois éléments sont écrits entre parenthèses intérieures, puisque le nombre de colonnes est de trois. Graphiquement, notre tableau ressemblera à un tableau à deux dimensions (voir Figure 5).

Figure 5 - Tableaux en C++

Dans chaque cellule d'un tableau à deux dimensions un la valeur est affichée, l'adresse de la cellule donnée est affichée dans le coin inférieur droit. L'adresse de cellule d'un tableau à deux dimensions est le nom du tableau, le numéro de ligne et le numéro de colonne.

Développons un programme simple pour traiter un tableau à deux dimensions, appelé "Labyrinthe". Le labyrinthe doit être construit sur la base d'un tableau à deux dimensions. La taille du labyrinthe dépend de vous.

// array2.cpp : définit le point d'entrée pour l'application console. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); écoute<< static_cast(176); ) sinon cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// code Code :: Blocs

// Code Dev-C++

// array2.cpp : définit le point d'entrée pour l'application console. #comprendre en utilisant l'espace de noms std ; int main(int argc, char* argv) ( // 1-conditionnellement "murs du labyrinthe" // 2-"chemin correct, sortie du labyrinthe" // 0-"faux chemin" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // initialisation d'un tableau à deux dimensions ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1, (1,2,2,2,2,2,2,1, 2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0,0 ,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2,0, 0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1,0 ,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,1,), (1 ,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1, (1,1,0,0,0, 1,0 ,0,1,1,2,1,1,1,1,0,0,0,0,1, (1,0,0,1,0,0,0,0,0,1 , 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1,1,1,1, 2 ,1,0,0,0,0,1, (1,2,2,2,2,2,2,2,2,2,2,2,2,2,1,0,1, 1 ,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,), (1,2,1 , 1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1,2,2,2, 1 ,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2,1,2,1,0 , 1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1 ,2,1,0,1,1,1,1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0, 0,0,0,0,0,0,0,0,2,1, (1,2,1,2,1,2,2,2,1,0,1,1,1,1 ,1 ,1,0,1,2,1,), (1,2,1,2,1,1,1,1,1,0,0,0,1,0,1,0,0, 1, 2,1,), (1,2,1,2,2,1,0,0,1,1,1,0,0,0,1,0,1,1,2,1,) , ( 1,2,1,1,2,1,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1 ,1 ,2,1,0,0,1,1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1, 1, 0,1,2,2,2,2,2,2,2,2,2,2,1, (1,2,1,1,2,1,0,0,1,2 ,1,1 ,1,1,1,1,1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1, 1,1, 1,1,1,2,2,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2 ,2,2 ,1,), (1,2,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1, ), (1 ,2,1,1,2,1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2, 2,2, 2,1,0,1,1,2,2,2,2,0,0,1,0,0,0,1, (1,1,1,1,1,1 ,1,1,1 ,1,1,1,1,1,1,1,1,1,1,1,) ); // deux boucles - interne et externe, qui accèdent à chaque élément du tableau pour (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); écoute<< static_cast(176); ) sinon cout<< " "; // вывести два пробела cout << endl; } return 0; }

Les chemins corrects et faux pourraient être désignés par le même nombre, par exemple, zéro, mais pour plus de clarté, le chemin correct est indiqué par le nombre 2. Le tableau a été initialisé manuellement, uniquement pour simplifier le programme. Étant donné que le programme traite un tableau à deux dimensions, deux boucles sont nécessaires pour basculer entre les éléments d'un tableau à deux dimensions. La première boucle for bascule entre les lignes d'un tableau à deux dimensions. Puisqu'il y a 33 lignes dans un tableau à deux dimensions, la variable de compteur i est incrémentée de 0 à 33, ligne 46. À l'intérieur de la première boucle se trouve une boucle for qui parcourt les éléments d'une ligne d'un tableau à deux dimensions. Dans le corps de la deuxième boucle for, une opération de conversion de type de données unaire est effectuée à l'intérieur - static_cast<>() , qui imprime le caractère , au numéro 176. L'opération de conversion de type de données est dupliquée pour augmenter la largeur du labyrinthe. Le résultat du programme (voir Figure 6).

Figure 6 - Tableaux en C++

Les tableaux sont conçus pour stocker plusieurs valeurs du même type. Par exemple, dans le programme Fahrenheit à Celsius, nous avons calculé la valeur de température moyenne à partir de trois. S'il n'y a pas trois valeurs, mais bien plus, alors les tableaux doivent être utilisés ici.

Avant qu'un tableau puisse être utilisé, il doit être défini. Une définition de tableau comprend : le type de données stockées dans le tableau, le nom du tableau et le nombre d'éléments du tableau entre crochets :

tableau d'entiers ;

Dans ce code, nous avons défini un tableau avec l'identifiant (nom) tableau (tableau) de dix éléments de type int.
Sous cette forme, tous les éléments du tableau ne sont pas encore initialisés. Pour les initialiser lors de la déclaration, utilisez la syntaxe suivante :

tableau int = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Dans ce cas, le premier élément du tableau se voit attribuer la valeur 0 et le dernier élément se voit attribuer la valeur 9.
Les boucles peuvent être utilisées pour attribuer des valeurs aux éléments d'un tableau. Le plus approprié pour cela serait une boucle for.

code c++ tableau d'entiers ; // définition de tableau pour (int i = 0; i< 10; i++) { array[i] = i; }

Ici, nous nous référons à chaque élément du tableau via l'index - le nombre entre crochets. A chaque itération de la boucle, elle prend des valeurs de zéro à 9.

Notez que la numérotation des index commence à zéro. Par conséquent, le nombre d'index est toujours un de moins que le nombre d'éléments du tableau.

À l'exception des crochets et d'un index, un élément de tableau s'utilise comme n'importe quelle autre variable.

Cordes

Jusqu'à présent, nous ne pouvions stocker des chaînes que dans des constantes : "Constant String Example". Dans les variables, nous ne pourrions stocker qu'un seul caractère - dans le type char. C++ utilise deux types de chaînes : un tableau d'éléments de type char et de type str. Nous allons maintenant nous concentrer sur la première option.

Nous avons besoin d'un tableau pour stocker une chaîne. Cela ressemble à ceci :

chaîne de caractères = ("c","t","p","o"."k","a");

Heureusement, il existe un moyen plus simple :)

chaîne de caractères = "chaîne" ;

Dans ce cas, un tableau de sept éléments sera automatiquement créé. Pourquoi sur sept ? Le fait est que chaque ligne doit se terminer par le caractère constant "\0", qui représente un octet vide.

Dans les exemples précédents, si nous essayons d'entrer une chaîne de plus de six caractères dans le tableau de chaînes, le tableau débordera. vous ne pouvez pas modifier la taille du tableau pendant l'exécution du programme (mais pas toujours) :

charstring ; // la chaîne peut stocker six caractères et "\0"

chaîne = "chaîne !" ; // la chaîne contient sept caractères
Ce n'est pas recommandé :)

Il y a encore un point sur lequel je voudrais attirer votre attention. Lorsque l'utilisateur saisit une chaîne, les espaces sont comptés comme "\0". Nous n'entrerons pas encore de chaînes dans nos programmes, donc je n'expliquerai pas ce cas en détail.

Tableaux de tableaux (tableaux à deux dimensions)

Et enfin, nous arrivons à la chose la plus importante dans ce numéro.

La carte dans les jeux stratégiques (et pas seulement) (RTS) est divisée en cellules (en anglais - tuile, tuile). Ces cellules sont commodément représentées à l'aide d'un tableau à deux dimensions.

Dans cet exemple, nous continuerons à travailler avec le programme pseudo_game et, à l'aide d'un tableau à deux dimensions, nous modéliserons une carte sur laquelle le joueur pourra se déplacer. Jusqu'à présent, le "mouvement" était représenté par des coordonnées x, y.

Les cellules seront représentées par des symboles. La taille de la "carte" est de 15x20. Quinze de haut, vingt de large. Nous allons représenter le joueur avec le symbole T.

Ajoutez d'abord le fichier d'en-tête stdlib.h

Pseudo_game amélioré

Je ne fournirai que des extraits de code. Il est souhaitable que vous ayez un programme complet sous les yeux. Vous pouvez le trouver dans la section "listes des programmes" - pseudo_game_0_2. Il compile et s'exécute. Copiez-le simplement dans l'éditeur de votre IDE et suivez le texte.

Initialisation des données :

code c++ acte de caractère; // variable pour lire l'entrée utilisateur int ch ; // variable pour stocker la valeur réduite de la variable act int x = 0; // deux variables pour stocker les coordonnées du joueur int y = 0; charmep ; // tableau pour stocker la carte de jeu // initialisation du tableau pour (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Ici, le nouvel opérateur pour nous est la définition d'un tableau à deux dimensions. Mais cela ne diffère presque pas de celui unidimensionnel, juste une paire de crochets supplémentaires est ajoutée. Dans les premières parenthèses, nous avons indiqué le nombre de lignes, dans la seconde - le nombre de colonnes.

Après cela, en deux boucles, nous initialisons chaque élément du tableau avec la valeur " " - qui est juste un caractère d'espacement. Premièrement - dans la boucle externe, nous parcourons toutes les lignes. Pour chaque ligne de la boucle interne, nous "parcourons" les colonnes.

Je vais donner un exemple détaillé : après plusieurs itérations de la boucle externe, le compteur i devient égal à 9. Le corps de la boucle externe commence à s'exécuter : la variable j (compteur de la boucle interne) est initialisée à zéro, la condition est coché, et le corps de la boucle interne est exécuté : map = " ";, c'est-à-dire que le premier caractère (index zéro) de la dixième ligne (n'oubliez pas que le décompte part de zéro) se voit attribuer un espace. Ensuite, le compteur j est affecté à 1, le corps de la boucle est exécuté... et ainsi de suite jusqu'à ce que le compteur j devienne égal à 20 - la condition n'est pas remplie et la boucle interne sort. Ensuite, le compteur externe est incrémenté. Maintenant, c'est 10 et le corps de la boucle externe est exécuté à nouveau...

Après initialisation avec des espaces, nous plaçons le personnage de notre jeu dans la première colonne de la première ligne.

Au début de la boucle principale, nous appelons la fonction system() pour effacer l'écran de la sortie passée.

Ensuite, il y a deux cycles similaires aux cycles d'initialisation. Ils permettent d'afficher les éléments d'un tableau à l'écran. La seule différence significative est la sortie d'un caractère de saut de ligne à la fin du corps de la première boucle.

Eh bien, il y a une ramification dans laquelle il est déterminé quelle touche est enfoncée. La ramification elle-même a peu changé depuis la dernière fois, mais il y a des différences dans le contenu des blocs : premièrement, nous attribuons un espace aux coordonnées sur lesquelles se trouve l'objet. C'est-à-dire que nous effaçons l'endroit précédent. Ensuite, nous changeons l'une des coordonnées. Et puis, à l'élément du tableau avec les nouveaux index, nous attribuons le symbole "T".

Exemple pour le code "75" - déplacement vers la gauche :

code c++ si sinon (ch == 75) ( map[x][y] = " "; y--; map[x][y] = "T"; )

Eh bien, c'est tout en général. Pour le moment, nous avons une carte 15x20 sur laquelle vous pouvez utiliser les flèches pour déplacer le personnage - la lettre "T". Pas mal pour la sixième leçon ! Cette application deviendra la base de tous nos programmes de console. Il n'y aura pas d'améliorations graphiques. Vous ne pouvez tout simplement pas tirer plus de la console DOS, et nous ne considérerons pas la console Windows. Cela permettra d'économiser beaucoup de temps et d'efforts.

J'ai commenté en détail le programme pseudo_game et vous le comprendrez probablement sans difficulté. Si ce n'est pas le cas, relisez la liste du programme et cette version jusqu'à ce que vous le compreniez :). Des exercices vous aideront à consolider le matériel. L'exercice est un must. Si quelque chose n'est pas clair, écrivez à mon e-mail - je vais essayer de vous aider.

Des exercices:

1. Dans la liste complète du programme, j'ai utilisé le branchement de commutateur. Le code pour un si bloc de branche est également affiché ici. Ajoutez les blocs if restants.

2. Le programme peut maintenant écrire dans des éléments de tableau inexistants. Faites une vérification hors limites.

3. Pour vous entraîner, créez un programme qui dessine deux champs de bataille à l'écran. Le premier - le joueur, le second - l'ennemi. Le deuxième champ doit être situé à droite du premier.
Remplissez les cellules intérieures avec un espace. Pour tracer une bordure, utilisez un signe moins et une ligne de séparation vers l'avant : -, |, et pour les coins - un signe dièse #. À gauche de chaque champ se trouve une colonne de nombres ; haut - lettres.
Vous aurez peut-être besoin de plusieurs boucles pour initialiser le champ entier. Voici à quoi pourrait ressembler le code pour remplir la colonne de nombres dans le deuxième champ :

code c++ chaîne entière ; // variable représentant les lignes int colonne ; // variable représentant les colonnes char map ; colonne = 15 ; pour (chaîne = 2; chaîne< 12; string++) { map = string - 1; }