Un tableau bidimensionnel en Pascal est traité comme un tableau unidimensionnel dont le type d'élément est également un tableau (tableau de tableaux). La position des éléments dans les tableaux Pascal bidimensionnels est décrite par deux indices. Ils peuvent être présentés sous forme de tableau rectangulaire ou de matrice.
Considérons un tableau Pascal bidimensionnel d'une dimension de 3*3, c'est-à-dire qu'il aura trois lignes et chaque ligne aura trois éléments :
Chaque élément a son propre numéro, comme les tableaux unidimensionnels, mais maintenant le numéro se compose déjà de deux nombres : le numéro de la ligne dans laquelle se trouve l'élément et le numéro de la colonne. Ainsi, le numéro d’élément est déterminé par l’intersection d’une ligne et d’une colonne. Par exemple, un 21 est l'élément qui apparaît dans la deuxième ligne et la première colonne.
Description d'un tableau Pascal bidimensionnel.
Il existe plusieurs façons de déclarer un tableau Pascal bidimensionnel.
Nous savons déjà comment décrire des tableaux unidimensionnels dont les éléments peuvent être de n'importe quel type et, par conséquent, les éléments eux-mêmes peuvent être des tableaux. Considérez la description suivante des types et des variables :
Un exemple de description d'un tableau Pascal bidimensionnelTaper
Vecteur = tableau de<тип_элементов>;
Matrix= tableau de vecteurs ;
Var m : matrice ;
Nous avons déclaré un tableau Pascal bidimensionnel m, composé de 10 lignes comportant chacune 5 colonnes. Dans ce cas, chaque i-ème ligne est accessible avec m[i], et chaque j-ème élément à l'intérieur de la i-ème ligne est accessible avec m[i,j].
La définition des types pour les tableaux Pascal bidimensionnels peut également être spécifiée sur une seule ligne :
Taper
Matrix= tableau de tableau de< тип элементов >;
ou encore plus simple :
taper
matrice = tableau de<тип элементов>;
L'accès aux éléments d'un tableau bidimensionnel a la forme : M [i, j]. Cela signifie que nous voulons obtenir l’élément situé dans la i-ème ligne et la j-ème colonne. L’essentiel ici est de ne pas confondre les lignes avec les colonnes, sinon on risque à nouveau d’accéder à un élément inexistant. Par exemple, accéder à l'élément M a la notation correcte, mais peut provoquer une erreur dans le programme.
Opérations de base avec des tableaux Pascal bidimensionnels
Tout ce qui a été dit sur les opérations de base avec les tableaux unidimensionnels est également vrai pour les matrices. La seule action pouvant être effectuée sur des matrices entières du même type est l'affectation. Autrement dit, si notre programme décrit deux matrices du même type, par exemple,
taper
matrice= tableau d'entiers ;
var
a, b : matrice ;
puis pendant l'exécution du programme, vous pouvez attribuer la matrice un valeur matricielle b(une := b). Toutes les autres actions sont effectuées élément par élément et toutes les opérations valides définies pour le type de données des éléments du tableau peuvent être effectuées sur les éléments. Cela signifie que si un tableau est constitué d'entiers, alors les opérations définies pour les entiers peuvent être effectuées sur ses éléments, mais si le tableau est constitué de caractères, alors les opérations définies pour travailler avec des caractères peuvent leur être appliquées.
Entrée d'un tableau Pascal bidimensionnel.
Pour saisir séquentiellement les éléments d'un tableau unidimensionnel, nous avons utilisé une boucle for dans laquelle nous avons modifié la valeur d'index du 1er au dernier. Mais la position d'un élément dans un tableau Pascal bidimensionnel est déterminée par deux indices : le numéro de ligne et le numéro de colonne. Cela signifie que nous devrons modifier séquentiellement le numéro de ligne du 1er au dernier et, dans chaque ligne, parcourir les éléments de la colonne du 1er au dernier. Cela signifie que nous aurons besoin de deux boucles for, l’une étant imbriquée dans l’autre.
Regardons un exemple de saisie d'un tableau Pascal bidimensionnel à partir du clavier :
Un exemple de programme pour saisir un tableau Pascal bidimensionnel à partir du claviertaper
matrice= tableau d'entiers ;
var
a, : matrice ;
je, j : entier ; (index de tableau)
commencer
for i:=1 à 5 do (boucle pour parcourir toutes les lignes)
readln(a[i,j]); (saisie au clavier d'un élément dans la i-ème ligne et la j-ème colonne)
Un tableau Pascal bidimensionnel peut être rempli de manière aléatoire, c'est-à-dire utilisez la fonction aléatoire (N) et attribuez également la valeur d'une expression à chaque élément de la matrice. La méthode de remplissage d'un tableau Pascal bidimensionnel dépend de la tâche à accomplir, mais dans tous les cas, chaque élément de chaque ligne et chaque colonne doit être défini.
Impression d'un tableau Pascal bidimensionnel à l'écran.
L'impression des éléments d'un tableau Pascal bidimensionnel s'effectue également de manière séquentielle, il faut imprimer les éléments de chaque ligne et de chaque colonne. En même temps, j'aimerais que les éléments qui sont sur la même ligne soient imprimés côte à côte, c'est à dire dans une rangée et les éléments de colonne étaient situés les uns en dessous des autres. Pour ce faire, vous devez effectuer la séquence d'actions suivante (considérez un fragment de programme pour le tableau décrit dans l'exemple précédent) :
Un exemple de programme pour imprimer un tableau Pascal bidimensionnelfor i:=1 à 5 do (boucle pour parcourir toutes les lignes)
commencer
pour j:=1 à 10 do (itérer tous les éléments d'une ligne par colonne)
écrire(a[i,j]:4); (éléments d'impression situés dans la ième ligne de la matrice sur une seule ligne d'écran, avec 4 positions allouées pour l'affichage de chaque élément)
écrire ; (avant de changer le numéro de ligne dans la matrice, vous devez déplacer le curseur au début d'une nouvelle ligne d'écran)
fin ;
Note ( C'est important!): très souvent, dans les programmes des étudiants, une erreur se produit lorsqu'ils tentent de saisir à partir du clavier ou d'afficher un tableau comme suit : readln (a), writeln (a), où UN est une variable tableau. En même temps, ils sont surpris par le message du compilateur indiquant qu'une variable de ce type ne peut être ni lue ni imprimée. Peut-être comprendrez-vous pourquoi cela ne peut pas être fait si vous imaginez N tasses alignées et dans vos mains, par exemple, une bouilloire d'eau. Pouvez-vous utiliser la commande « verser de l'eau » pour remplir toutes les tasses en même temps ? Peu importe vos efforts, vous devrez verser dans chaque tasse séparément. Le remplissage et l'affichage des éléments du tableau doivent également être effectués de manière séquentielle et élément par élément, car Dans la mémoire de l'ordinateur, les éléments du tableau sont situés dans des cellules consécutives.
Représentation d'un tableau Pascal bidimensionnel en mémoire
Les éléments d'un tableau abstrait dans la mémoire de la machine sont physiquement localisés séquentiellement, selon la description. Dans ce cas, chaque élément occupe le nombre d'octets en mémoire correspondant à sa taille. Par exemple, si un tableau est constitué d’éléments de type entier, alors chaque élément occupera deux octets. Et le tableau entier prendra S^2 octets, où S est le nombre d'éléments dans le tableau.
Et combien d'espace prendra un tableau composé de tableaux, c'est-à-dire matrice? Évidemment : S i^S j, où S i est le nombre de lignes et S j est le nombre d'éléments dans chaque ligne. Par exemple, pour un tableau comme
Matrix = tableau d'entiers ;
12 octets de mémoire seront nécessaires.
Comment les éléments de ce tableau seront-ils localisés en mémoire ? Considérons la disposition d'un tableau M de type matriciel en mémoire.
Pour chaque élément M de type entier, deux cellules mémoire sont allouées. Le placement de la mémoire se fait de bas en haut. Les éléments sont placés dans l'ordre de changement d'index, qui correspond au motif de boucle imbriquée : la première ligne est placée en premier, puis la deuxième, la troisième... Au sein de la ligne, les éléments vont dans l'ordre : premier, deuxième, etc.
Comme nous le savons, l'accès à n'importe quelle variable n'est possible que si l'adresse de la cellule mémoire dans laquelle la variable est stockée est connue. Une mémoire spécifique est allouée à une variable lors du chargement du programme, c'est-à-dire qu'une correspondance mutuelle est établie entre la variable et l'adresse de la cellule. Mais si nous déclarons une variable sous forme de tableau, alors le programme « connaît » l'adresse du début du tableau, c'est-à-dire son premier élément. Comment accéder à tous les autres éléments du tableau ? Lors de l'accès réel à une cellule mémoire dans laquelle est stocké un élément d'un tableau bidimensionnel, le système calcule son adresse à l'aide de la formule :
Adresse + SizeElem * Cols *(I -1)+ SizeElem *(J -1),
où Addr est l'adresse de départ réelle à laquelle le tableau se trouve en mémoire ; I, J – indices d'éléments dans un tableau à deux dimensions ; SizeElem – taille de l'élément du tableau (par exemple, deux octets pour les éléments de type entier) ; Cols – nombre d'éléments dans la ligne.
L'expression SizeElem * Cols *(I -1)+ SizeElem *(J -1) est appelée le décalage par rapport au début du tableau.
Quelle quantité de mémoire est allouée au tableau ?
Considérons non pas tant la question de la quantité de mémoire allouée au tableau (nous en avons discuté dans la section précédente), mais quelle est la taille maximale autorisée du tableau, étant donné la quantité limitée de mémoire.
Pour le fonctionnement du programme, la mémoire est allouée en segments de 64 Ko chacun, et au moins l'un d'entre eux est défini comme segment de données. C'est dans ce segment que se trouvent les données que le programme va traiter. Aucune variable de programme ne peut être située dans plus d'un segment. Par conséquent, même s’il n’y a qu’une seule variable dans le segment, décrit comme un tableau, elle ne pourra pas recevoir plus de 65 536 octets. Mais il est presque certain qu'en plus du tableau, d'autres variables seront décrites dans le segment de données, de sorte que la quantité réelle de mémoire pouvant être allouée au tableau est trouvée par la formule : 65536-S, où S est la quantité de mémoire déjà allouée pour d’autres variables.
Pourquoi avons-nous besoin de savoir cela? Afin de ne pas être surpris si, lors de la compilation, le traducteur affiche un message d'erreur concernant la déclaration d'un tableau trop long, lorsque le programme rencontre une description (correcte du point de vue de la syntaxe) :
Tapez myArray= tableau d’entiers ;
Vous savez déjà que, étant donné la représentation des entiers sur deux octets, il est en fait possible de déclarer un tableau avec un nombre d'éléments égal à 65536/2 –1=32767. Et seulement s’il n’y a pas d’autres variables. Les tableaux à deux dimensions doivent avoir des limites d'index encore plus petites.
Exemples de résolution de problèmes avec des tableaux Pascal bidimensionnels
Tâche: Trouvez le produit d’éléments matriciels non nuls.
Solution:
- Pour résoudre ce problème, nous avons besoin de variables : une matrice constituée, par exemple, d'éléments entiers ; P – produit d'éléments différents de 0 ; I, J – indices de tableau ; N, M – nombre de lignes et de colonnes dans la matrice.
- Les données d'entrée sont N, M - nous saisirons leurs valeurs à partir du clavier ; matrice – nous saisirons la matrice sous la forme d’une procédure ; nous remplirons la matrice de manière aléatoire, c’est-à-dire en utilisant la fonction random().
- Les données de sortie seront la valeur de la variable P (produit).
- Pour vérifier la bonne exécution du programme, il est nécessaire d'afficher la matrice à l'écran ; pour cela nous formaliserons la procédure d'affichage de la matrice.
- Progrès dans la résolution du problème :
Parlons d'abord de l'exécution du programme principal ; nous aborderons la mise en œuvre des procédures un peu plus tard :
- entrons les valeurs N et M ;
- Introduisons un tableau Pascal bidimensionnel, pour cela nous nous tournons vers la procédure vvod (a), où a est une matrice ;
- Imprimons la matrice résultante, pour ce faire, utilisez la procédure print (a) ;
- Attribuons la valeur initiale à la variable P =1 ;
- Nous allons parcourir séquentiellement toutes les lignes I du 1er au Nième, dans chaque ligne nous allons parcourir toutes les colonnes J du 1er au Mième, pour chaque élément de la matrice nous vérifierons la condition : si un ij ? 0, alors le produit P sera multiplié par l'élément a ij (P = P * a ij) ;
- Affichons la valeur du produit d'éléments matriciels non nuls – P ;
Parlons maintenant des procédures.
Commentaire (C'est important!) Un paramètre de procédure peut être n'importe quelle variable d'un type prédéfini, ce qui signifie que pour passer un tableau en paramètre à une procédure, son type doit être décrit au préalable. Par exemple:
Taper
Matrice=tableau d'entiers ;
amorce de procédure (a : matrice) ;
..............................
Revenons maintenant à nos procédures.
La procédure de saisie d'une matrice s'appelle vvod, le paramètre de la procédure est la matrice, et elle doit donc être passée au programme principal, donc le paramètre doit être passé par référence. L’en-tête de notre procédure ressemblera alors à ceci :
Procédure vvod (var m : matrice) ;
Pour implémenter des boucles imbriquées dans une procédure, nous avons besoin de variables de compteur locales, par exemple k et h. L'algorithme de remplissage de la matrice a déjà été évoqué, nous ne le répéterons donc pas.
La procédure d'affichage d'une matrice à l'écran s'appelle print , le paramètre de la procédure est la matrice, mais dans ce cas c'est un paramètre d'entrée donc passé par valeur. L'en-tête de cette procédure ressemblera à ceci :
Impression de procédure (m : matrice) ;
Et encore une fois, pour implémenter des boucles imbriquées dans une procédure, nous avons besoin de compteurs, qu'ils soient appelés de la même manière - k et h. L'algorithme d'affichage de la matrice à l'écran a été décrit ci-dessus, nous utiliserons cette description.
Exemple de programme de tableau bidimensionnel PascalProduction de programmes ;
Taper
Matrice=tableau d'entiers ;
Var
A : matrice ;
N, m, i, j : octet ;
P : entier ;
Procédure vvod (var m : matrice) ;
Var k, h : octet ;
Commencer
Pour i:=1 à n faire (la variable n de la procédure est globale, et donc « connue »)
Pour j:=1 à m faire (la variable m de la procédure est globale, et donc « connue »)
M := aléatoire (10 );
Fin;
Impression de procédure (m : matrice) ;
Var k, h : octet ;
Commencer
Pour i:=1 à n faire
commencer
Pour j:=1 à m faire
Écrire(M:4);
Écrire ;
fin ;
Fin ;
Begin (début du programme principal)
Writeln("Entrez la dimension de la matrice :");
Lecture(N, M);
Vvod(a);
Imprimer(a);
P : = 1 ;
Pour i:=1 à N faire
Pour j:=1 à M faire
Si un<>0 alors p:=p*a;
Writeln(p);
Fin.
Un tableau est une structure de données représentée comme un groupe de cellules du 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 que sont les pointeurs, je vous le dirai un peu plus tard. Une cellule de données individuelle d’un tableau est appelée un élément du tableau. Les éléments d'un tableau peuvent être des données de n'importe quel type. Les tableaux peuvent avoir une ou plusieurs dimensions. En fonction du nombre de dimensions, les tableaux sont divisés en tableaux à une dimension, tableaux à deux dimensions, tableaux à trois dimensions, et ainsi de suite jusqu'à un tableau à n dimensions. Les tableaux unidimensionnels et bidimensionnels sont le plus souvent utilisés en programmation, nous ne considérerons donc que ces tableaux.
Tableaux unidimensionnels en C++
Un tableau unidimensionnel est un tableau avec un paramètre caractérisant le nombre d'éléments du tableau unidimensionnel. En fait, un tableau unidimensionnel est un tableau qui ne peut avoir qu’une seule 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'indice 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 des cellules est un entier non négatif par lequel vous pouvez accéder à chaque cellule du tableau et y effectuer n'importe quelle action ( cellule).
//syntaxe de déclaration d'un tableau unidimensionnel en C++ : /*type de données*/ /*nom d'un tableau unidimensionnel*/; //un exemple de déclaration d'un tableau unidimensionnel illustré à la figure 1 : int a;
où, int est un 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 dans lesquels la taille du tableau unidimensionnel est spécifiée ; c'est ce qui distingue le 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 respectivement des tailles 10 et 16. De plus, dans cette méthode de déclaration, 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) ; // initialise le tableau sans déterminer sa taille.
Dans ce cas, le compilateur déterminera lui-même la taille du tableau unidimensionnel. La taille d'un tableau ne peut être omise que lors de son initialisation ; lors de la déclaration normale d'un tableau, la taille du tableau doit être spécifiée. 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
// code Code :: Blocs
// Code Dev-C++
// array.cpp : Définit le point d'entrée de l'application console. #inclure
DANS lignes 10 à 11 Un tableau entier unidimensionnel nommé array1 a été déclaré et initialisé, dont la taille est de 16 cellules, c'est-à-dire qu'un tel tableau peut stocker 16 nombres. Tout traitement de tableau n'est possible qu'en conjonction avec des boucles. C'est à vous de décider quelle boucle choisir pour traiter le tableau. Mais il est le mieux adapté à cette tâche. Nous utiliserons la variable counter counter pour accéder aux éléments du tableau unidimensionnel array1. La condition pour continuer la boucle for contient un signe d'inégalité stricte, puisqu'il n'y a pas de seizième index dans le tableau unidimensionnel array1. Et comme la numérotation des cellules commence à zéro, le tableau contient 16 éléments. Dans le corps de la boucle for, l'opérateur cout imprime les éléments d'un tableau unidimensionnel (voir Figure 2).
Obrabotka massiva indexe l'élément massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 2 - Tableaux en C++
Développons un autre programme pour traiter un tableau unidimensionnel en C++. Le programme doit lire séquentiellement dix nombres saisis à partir du clavier. Tous les nombres saisis sont résumés et le résultat est affiché à l'écran.
// array_sum.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
// code Code :: Blocs
// Code Dev-C++
// array_sum.cpp : Définit le point d'entrée de l'application console. #inclure
Avant de traiter un tableau, il doit être déclaré et la taille d'un tableau unidimensionnel est de 10, car cela est stipulé par la condition de la tâche. Dans la variable somme, nous accumulerons la somme des éléments d’un tableau unidimensionnel. La première boucle for remplit le tableau unidimensionnel déclaré avec des nombres saisis au clavier, lignes 12 à 13. La variable counter est utilisée pour accéder séquentiellement aux éléments du tableau unidimensionnel array1 , à partir de l'index 0 et jusqu'au 9 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. Le résultat du programme est présenté 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 Pour continuer, appuyez sur n'importe quelle touche. . .
Figure 3 - Tableaux en C++
Tout d'abord, les 10 nombres ont été saisis séquentiellement, après quoi un tableau unidimensionnel a été affiché et la somme des nombres du tableau a été imprimée.
Tableaux bidimensionnels en C++
Jusqu'à présent, nous avons considéré des tableaux unidimensionnels, auxquels on ne peut pas toujours se limiter. Disons que vous devez 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 du 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 ordinaire, avec des lignes et des colonnes. En fait, un tableau bidimensionnel est un tableau unidimensionnel de tableaux unidimensionnels. La structure d'un tableau bidimensionnel, nommé a, de taille m par n est présenté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 d'un tableau à deux dimensions ;
m * n — nombre d'éléments du tableau.
// syntaxe de déclaration d'un tableau à deux dimensions /*type de données*/ /*nom du tableau*/;
En déclarant un tableau à deux dimensions, ainsi qu'en déclarant un tableau à une dimension, vous devez tout d'abord spécifier :
- Type de données;
- nom du tableau.
Après cela, les premiers crochets indiquent le nombre de lignes du tableau à deux dimensions et les seconds crochets indiquent le nombre de colonnes du tableau à deux dimensions. Un tableau bidimensionnel se distingue visuellement d’un tableau unidimensionnel par une deuxième paire de crochets. Regardons un exemple de déclaration d'un tableau à deux dimensions. Disons que nous devons déclarer un tableau à deux dimensions avec un 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 est le nom du tableau d'entiers
- le nombre entre les premiers crochets indique le nombre de lignes du tableau bidimensionnel, dans ce cas il y en a 5 ;
- le nombre entre les deuxièmes crochets indique le nombre de colonnes du tableau bidimensionnel, dans ce cas il y en a 3.
// initialisation d'un tableau à deux dimensions : int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );
Ce tableau comporte 5 lignes et 3 colonnes. après le signe d'attribution, des accolades générales sont placées, à l'intérieur desquelles sont placées autant de paires d'accolades qu'il devrait y avoir de lignes dans un tableau bidimensionnel, et ces parenthèses 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. Dans toutes les accolades, le nombre d’éléments doit être le même. Puisqu’il y a cinq lignes dans le tableau, il y a également 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 cette cellule 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 bidimensionnel, appelé « Labyrinthe ». Le labyrinthe doit être construit sur la base d’un réseau bidimensionnel. Nous choisirons la taille du labyrinthe à notre discrétion.
// array2.cpp : Définit le point d'entrée de l'application console. #include "stdafx.h" #include
// code Code :: Blocs
// Code Dev-C++
// array2.cpp : Définit le point d'entrée de l'application console. #inclure
Les chemins corrects et faux pourraient être désignés par le même numéro, par exemple zéro, mais pour plus de clarté, le chemin correct est désigné par le chiffre 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 du 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 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 de 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 numéro de caractère 176. L'opération de conversion du 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++
Lors de la résolution de problèmes avec une grande quantité de données du même type, l'utilisation de variables avec des noms différents qui ne sont pas classés par adresses mémoire rend la programmation difficile. Dans de tels cas, le langage C utilise des objets appelés tableaux.
est un morceau de mémoire contigu contenant une séquence d'objets du même type, désignés par un nom.
Le tableau est caractérisé par les concepts de base suivants :
Élément de tableau (valeur de l'élément de tableau)– une valeur stockée dans une cellule mémoire spécifique située au sein du tableau, ainsi que l'adresse de cette cellule mémoire.
Chaque élément du tableau est caractérisé par trois valeurs :
- adresse de l'élément - l'adresse de la cellule mémoire de départ dans laquelle se trouve cet élément ;
- index de l'élément (numéro ordinal de l'élément dans le tableau) ;
- valeur de l'élément.
Adresse du tableau – l'adresse de l'élément de départ du tableau.
Le nom du tableau est un identifiant utilisé pour faire référence aux éléments du tableau.
Taille du tableau – nombre d'éléments du tableau
La taille de l'élément est le nombre d'octets occupés par un élément du tableau.
Graphiquement, l'emplacement du tableau dans la mémoire de l'ordinateur peut être représenté comme une bande continue d'adresses.
Le tableau montré sur la figure contient q éléments avec des indices de 0 à q-1. Chaque élément occupe k octets dans la mémoire de l'ordinateur et la disposition des éléments en mémoire est séquentielle.
Les adresses du i-ième élément du tableau sont
L'adresse du tableau est l'adresse de l'élément de départ (zéro) du tableau. Pour accéder aux éléments du tableau, on utilise le numéro de série (index) de l'élément dont la valeur initiale est 0. Ainsi, si un tableau contient q éléments, alors les indices des éléments du tableau varient de 0 à q-1.
La longueur du tableau est le nombre d'octets alloués en mémoire pour stocker tous les éléments du tableau.
Longueur du tableau = taille de l'élément * nombre d'éléments
La fonction peut être utilisée pour déterminer la taille d'un élément du tableau
int taille de (type);
Par exemple,
taille de (char) = 1 ;
taille de (int) = 4 ;
taille de (flotteur) = 4 ;
taille de (double) = 8 ;
Déclaration et initialisation des tableaux
Pour déclarer un tableau en C, la syntaxe suivante est utilisée :
tapez nom[dimension]=(init);
L'initialisation est un ensemble de valeurs initiales des éléments du tableau, spécifiées entre accolades, séparées par des virgules.
int a = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) ; // tableau a de 10 entiers
Si le nombre de valeurs d'initialisation spécifié dans les accolades est inférieur au nombre d'éléments du tableau spécifié entre crochets, alors tous les éléments restants du tableau (pour lesquels il n'y avait pas suffisamment de valeurs d'initialisation) seront nuls. Cette propriété est pratique à utiliser pour définir tous les éléments d’un tableau sur des valeurs nulles.
int b = (0); // tableau b de 10 éléments initialisé à 0
Si le tableau est initialisé lors de sa déclaration, alors les valeurs initiales constantes de ses éléments sont indiquées séparées par des virgules entre accolades. Dans ce cas, le nombre d’éléments entre crochets peut être omis.
int a = (1, 2, 3, 4, 5, 6, 7, 8, 9) ;
Lors de l'accès aux éléments du tableau, l'index de l'élément requis est indiqué entre crochets.
Exemple en C
1
2
3
4
5
6
7
8
#inclure
int main()
{
int une = ( 5, 4, 3, 2, 1 ); // le tableau a contient 5 éléments
printf("%d %d %d %d %d\n" , a, a, a, a, a);
getchar();
renvoie 0 ;
}
Résultat de l'exécution du programme :
Cependant, il est souvent nécessaire de définir les valeurs des éléments du tableau lors de l'exécution du programme. Cela utilise une déclaration de tableau sans initialisation. Dans ce cas, indiquer le nombre d’éléments entre crochets est obligatoire.
int un;
Pour définir les valeurs initiales des éléments du tableau, une boucle paramétrique est très souvent utilisée :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#inclure
int main()
{
int un;
int je;
// Saisie des éléments du tableau
pour (je = 0; je<5; i++)
{
printf("a[%d] = " , je);
scanf("%d" , &a[i]);
}
// Éléments du tableau de sortie
pour (je = 0; je<5; i++)
printf("%d " , a[i]); // un espace au format d'impression est requis
getchar(); getchar();
renvoie 0 ;
}
Résultat de l'exécution du programme 
Tableaux multidimensionnels
Les tableaux multidimensionnels peuvent également être déclarés en C. La différence entre un tableau multidimensionnel et un tableau unidimensionnel est que dans un tableau unidimensionnel, la position d'un élément est déterminée par un index, et dans un tableau multidimensionnel - par plusieurs. Un exemple de tableau multidimensionnel est une matrice.
Forme générale de déclaration d'un tableau multidimensionnel
tapez nom[dimension1][dimension2]...[dimensionm];
Les éléments d'un tableau multidimensionnel sont localisés dans des cellules RAM successives par ordre croissant d'adresses. Dans la mémoire d'un ordinateur, les éléments d'un tableau multidimensionnel sont disposés en ligne, par exemple un tableau à 2 lignes et 3 colonnes,
int un;
sera localisé en mémoire comme suit
Le nombre total d'éléments dans le tableau bidimensionnel donné est déterminé comme
Nombre de lignes * Nombre de colonnes = 2 * 3 = 6.
Le nombre d'octets de mémoire requis pour accueillir le tableau est donné par
Nombre d'éléments * Taille de l'élément = 6 * 4 = 24 octets.
Initialisation de tableaux multidimensionnels
Les valeurs des éléments d'un tableau multidimensionnel, comme dans le cas unidimensionnel, peuvent être spécifiées par des valeurs constantes lorsqu'elles sont déclarées, entre accolades (). Toutefois, dans ce cas, le nombre d’éléments en lignes et en colonnes doit être indiqué entre crochets.
Exemple en C
1
2
3
4
5
6
7
8
9
#inclure
int main()
{
int une = ( 1, 2, 3, 4, 5, 6 );
printf("%d %d %d\n" , a, a, a);
getchar();
renvoie 0 ;
}
Cependant, le plus souvent, vous devez saisir les valeurs des éléments d'un tableau multidimensionnel lors de l'exécution du programme. Pour cela, il est pratique d’utiliser une boucle paramétrique imbriquée.
Exemple en C
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#define _CRT_SECURE_NO_WARNINGS
#inclure
int main()
{
int un; // tableau de 2 lignes et 3 colonnes
int je, j;
// Saisie des éléments du tableau
pour (je = 0; je<2; i++) // boucle sur les lignes
{
pour (j = 0; j<3; j++) // boucle dans les colonnes
{
printf("a[%d][%d] = " , je, j);
scanf("%d" , &a[i][j]);
}
}
// Éléments du tableau de sortie
pour (je = 0; je<2; i++) // boucle sur les lignes
{
pour (j = 0; j<3; j++) // boucle dans les colonnes
{
printf("%d " , a[i][j]);
}
printf("\n" ); // nouvelle ligne
}
getchar(); getchar();
renvoie 0 ;
}
Passer un tableau à une fonction
Le traitement des tableaux peut être facilement organisé à l'aide de fonctions spéciales. Pour traiter un tableau, vous devez passer en arguments à la fonction
- adresse du tableau,
- taille du tableau.
L'exception concerne les fonctions de traitement de chaînes, où il suffit de transmettre uniquement l'adresse.
Lors du passage de variables comme arguments à une fonction, les données sont transmises sous forme de copies. Cela signifie que si la valeur d'un paramètre change dans une fonction, cela n'affectera pas sa valeur dans la fonction appelante.
Si une adresse de variable (ou une adresse de tableau) est transmise à une fonction, alors toutes les opérations effectuées dans la fonction sur les données dans la portée de l'adresse spécifiée sont effectuées sur les données d'origine, de sorte que le tableau d'origine (ou la valeur de la variable) puisse être modifié. par la fonction appelée.
Exemple dans un tableau C Dan de 10 éléments. Échangez les éléments les plus grands et les premiers du tableau. Pour un maximum d'opérations de recherche et d'échange d'éléments, utilisez la fonction.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define _CRT_SECURE_NO_WARNINGS
#inclure
// Fonction d'échange
changement nul (int *x, int n)
{
// x - pointeur vers le tableau (adresse du tableau)
// n - taille du tableau
int je;
int max, indice ;
maximum = x ;
indice = 0 ;
// Recherche de l'élément maximum
pour (i = 1; je
si (x[i]>max)
{
max = x[i];
indice = je ;
}
}
// Échange
x = x ;
x = maximum ;
}
// Fonction principale
int main()
{
int un;
int je;
pour (je = 0; je<10; i++)
{
printf("a[%d] = " , je);
scanf("%d" , &a[i]);
}
changement(a, 10); // appelle la fonction d'échange
// Éléments du tableau de sortie
pour (je = 0; je<10; i++)
printf("%d " , a[i]);
getchar();
getchar();
retour
p = p * x[je];
}
retourner p ;
}
// Fonction principale
int main()
{
int un; // a déclaré un tableau a de 5 éléments
int je;
int pr;
// Saisie des éléments du tableau
pour (je = 0; je<5; i++)
{
printf("a[%d] = " , je);
scanf("%d" , &a[i]); // &a[i] - adresse du i-ème élément du tableau
}
pr = fonction(une, 5); // calcule le produit
printf("\n pr = %d" , pr); // affiche le produit des éléments pairs
getchar(); getchar();
renvoie 0 ;
}
Sections: L'informatique
Sujet: Tableaux bidimensionnels. Remplissage d'un tableau bidimensionnel selon une règle donnée.
Objectifs: mettre en pratique les compétences nécessaires pour travailler avec des éléments d'un tableau bidimensionnel, apprendre à remplir des tableaux bidimensionnels selon une règle donnée, apprendre à déduire la relation entre le numéro de ligne et le numéro de colonne ; développement de la pensée logique des élèves.
PROGRÈS DE LA CLASSE
1. Actualisation des connaissances
Les tableaux dans lesquels la position des éléments est décrite par deux indices sont appelés bidimensionnels. La structure d’un tel réseau peut être représentée par une matrice rectangulaire. Chaque élément de la matrice est identifié de manière unique en indiquant le numéro de ligne et de colonne, le numéro de ligne est i, le numéro de colonne est j.
Considérons la matrice A de taille n*m :
| un 11 | un 12 | un 13 | un 14 |
| un 21 | un 22 | un 23 | un 24 |
| un 31 | un 32 | un 33 | un 34 |
Matrice de 3 lignes et 4 colonnes, nombre de lignes n=3, nombre de colonnes m=4. Chaque élément a son propre numéro, composé de deux nombres : le numéro de la ligne dans laquelle se trouve l'élément et le numéro de la colonne. Par exemple, a23 est un élément trouvé dans la deuxième ligne et la troisième colonne.
Un tableau bidimensionnel en Turbo Pascal peut être décrit de différentes manières. Pour décrire un tableau à deux dimensions, vous devez déterminer quel type de ses éléments sont et comment ils sont numérotés (de quel type d'index il s'agit). Il existe plusieurs façons de décrire un tableau à deux dimensions.
Const maxN =… ; (Nombre maximum de lignes)
maxM=… ; (Nombre maximum de colonnes)
1 voie
Tapez Mas = tableau de<тип элементов>; (Tableau unidimensionnel)
Tapez TMas = tableau de Mas ; (Tableau unidimensionnel dont les éléments sont des tableaux unidimensionnels)
Méthode 2
Tapez TMas = tableau de tableau de<тип
элементов>;
(Tableau unidimensionnel dont les éléments sont des tableaux unidimensionnels)
3 voies
Taper<имя типа>= tableau de<тип элементов>; (Tableau bidimensionnel)
La préférence est donnée à la troisième méthode de description d'un tableau bidimensionnel.
Par exemple:
Const N = 3 ; M=4 ;
Tapez TMas= tableau d'entiers ; (tableau bidimensionnel d'entiers)
La formation d'un tableau bidimensionnel peut s'effectuer de quatre manières : saisie au clavier, via un générateur de nombres aléatoires, selon une règle donnée, ou à l'aide d'un fichier.
1) Formation d'un tableau bidimensionnel à l'aide de la saisie au clavier et d'un algorithme de sortie ligne par ligne des éléments matriciels.
Const N=10 ; M=10 ;
Tapez Tmas= tableau d’entiers ;
Var A: Noël; je,j:entier;
Commencer
(Saisie des éléments de la matrice)
Pour i:=1 à N faire
Pour j:=1 à M faire
Lire un);
(Sortie des éléments matriciels)
Pour i:=1 à N, commencez
Pour j:=1 à M faire
Écrire(A:4); (La première ligne est imprimée)
Écrire (nouvelle ligne)
fin;
Fin.
2) Un fragment d'un programme permettant de générer un tableau bidimensionnel via un générateur de nombres aléatoires.
Commencer
Randomiser; (Initialisation du générateur de nombres aléatoires)
(Saisie des éléments de la matrice)
Pour i:=1 à N faire
Pour j:=1 à M faire
A:=aléatoire(45)-22 ;
2. Étudier du nouveau matériel. Remplir un tableau selon une règle
Considérons plusieurs fragments de programmes permettant de remplir un tableau bidimensionnel selon une certaine loi. Pour ce faire, vous devez dériver une règle de remplissage.
1. Remplissez le tableau A de taille n*m comme suit, par exemple
1
2
3
4
5
6
7 8
16 15
14 13
12 11
10 9
17 18
19 20
21 22
23 24
32 31
30 29
28 27
26 25
33 34
35 36
37 38
39 40
48 47
46 45
44 43
42 41
Le tableau est rempli selon le principe du « serpent ». Règle de remplissage : si le numéro de ligne est un nombre impair, alors A=(i-1)*m+j, sinon A=i*m-j+1.
programme M1A ;
n,m,i,j : entier ;
commencer
readln(n,m);
pour i:=1 à n, commence
pour j:=1 à m faire
commencer
si je mod 2 = 1 alors
A=(i-1)*m+j
autre
A=i*m-j+1 ;
écrire(A:3);
fin;
écrire;
fin;
lire;
fin.
Voici un exemple de programme pour une autre méthode de remplissage selon une règle donnée :
programme M1B ;
var A : tableau d’entiers ;
n,m,i,j : entier ;
c:entier;
commencer
readln(n,m);
c:=1;
pour i:=1 à n faire
commencer
pour j:=1 à m faire
commencer
UNE:=c;
si (i mod 2 = 0) et (j<>m) alors
décembre(c)
autre
inc(c);
écrire(A:3);
fin;
c:=c+m-1;
écrire;
fin;
lire;
fin.
2. Remplissez le tableau A selon le principe suivant :
1
0
2
0
3
0 4
0
5
0
6
0
7 0
8
0
9
0
10
0 11
0
12
0
13
0
14 0
programme M2 ;
var A : tableau d’entiers ;
n,m,i,j : entier ;
c:entier;
commencer
readln(n,m);
c:=0;
pour i:=1 à n faire
commencer
pour j:=1 à m faire
commencer
si (i-1+j) mod 2 = 0 alors
R :=0
autre
commencer
inc(c);
UNE:=c;
fin;
écrire(A:5);
fin;
écrire;
fin;
lire;
fin.
3. Remplissez le tableau A selon le principe suivant :
1
12 13
24 25
36
2
11 14
23 26
35
3
10 15
22 27
34
4
9
16 21
28 33
5
8
17 20
29 32
6
7
18 19
30 31
var A : tableau d’entiers ;
n,m,i,j : entier ;
c:entier;
commencer
readln(n,m);
c:=1;
pour j:=1 à m faire
commencer
pour i:=1 à n faire
commencer
UNE:=c;
si (j mod 2 = 0) et (i<>n) alors
décembre(c)
autre
inc(c);
fin;
c:=c+n-1;
fin;
pour i:=1 à n faire
commencer
pour j:=1 à m faire
écrire(A:5);
écrire;
fin;
lire;
fin.
4. Remplissez le tableau A selon le principe suivant :
1
2
3
4 5
2
3
4
5 1
3
4
5
1 2
4
5
1
2 3
5
1
2
3 4
var i,j,m,c,d : entier ;
commencer
c:=1;
readln(m);
pour j:=1 à m faire
commencer
je:=c;
d:=1;
répéter
A :=d ;
inc(je);
si je le suis alors
je:=1;
Inc(d);
jusqu'à ce que je = c ;
déc(c);
si c<= 0 then
c:=mc;
fin;
pour i:=1 à m faire
commencer
pour j:=1 à m faire
écrire(A:2);
écrire;
fin;
fin.
5. Remplissez le tableau A selon le principe suivant :
1
0
0
0 1
0
1
0
1 0
0
0
1
0 0
0
1
0
1 0
1
0
0
0 1
var m,i,j : entier ;
A : tableau d’entiers ;
commencer
readln(m);
pour i:=1 à m faire
commencer
pour j:=1 à m faire
commencer
si (i=j) ou (m-i+1=j) alors
R :=1
autre
A :=0 ;
écrire(A:2);
fin;
écrire;
fin;
fin.
3. Problèmes pour une solution indépendante
6
5
4
3
2 1
7
8
9
10 11
12
18 17
16 15
14 13
19 20
21 22
23 24
30 29
28 27
26 25
31 32
33 34
35 36
36
25 24
13 12
1
35 26
23 14
11 2
34 27
22 15
10 3
33 28
21 16
9 4
32 29
20 17
8 5
31 30
19 18
7 6
0
1
1
1 0
1
0
1
0 1
1
1
0
1 1
1
0
1
0 1
0
1
1
1 0
4) Remplissez le tableau selon le principe suivant :
31
32 33
34 35
36
25 26
27 28
29 30
19 20
21 22
23 24
13 14
15 16
17 18
7
8
9
10 11
12
1
2
3
4
5 6
5) Remplissez le tableau selon le principe suivant :
31
25 19
13
7 1
32 26
20 14
8 2
33 27
21 15
9 3
34 28
22 16
10 4
35 29
23 17
11 5
36 30
24 18
12 6
Devoirs:
1) Remplissez le tableau selon le principe suivant :
6
7
18 19
30 31
5
8
17 20
29 32
4
9
16 21
28 33
3
10 15
22 27
34
2
11 14
23 26
35
1
12 13
24 25
36
2) Remplissez le tableau selon le principe suivant :
31
32 33
34 35
36
30 29
28 27
26 25
19 20
21 22
23 24
18 17
16 15
14 13
7
8
9
10 11
12
6
5
4
3
2 1
3) Remplissez le tableau selon le principe suivant :
0
1
1
1 0
1
0
1
0 1
1
1
0
1 1
1
0
1
0 1
0
1
1
1 0