La possibilité d'utiliser des tableaux souffre de certaines limites dés que l'on souhaite gérer des variables plus complexes.
Prenons, par exemple, le cas où l'on voudrait gérer une liste de contacts, en fournissant leur nom, leur prénom, leur adresse et, pourquoi pas le nombre d'enfants qu'a ce contact.
En utilisant les tableaux, nous serions obligés de créer un tableau à deux dimentions pour le nom, un autre pour le prénom, un troisième pour l'adresse et un tableau d'entiers pour le nombre d'enfants.
Ce genre de gestion serait très difficile, car on ne disposerait pas des informations regroupées concernant ce contact.
On serait donc obligé de déterminer l'indice correspondant au contact dont on veux disposer des informations, et de réutiliser cet indice sur chacun des tableaux que l'on aura créé.
Sans compter que l'on pourrait souhaiter disposer également de son adresse E-mail, de sa date de naissance, du nom de son époux/épouse et que sais-je encore…
Il serait donc largement préférable de pouvoir définir pour chaque contact son nom, son prénom etc tout en pouvant y accéder du simple fait que l'on aie déterminé le contact auquel on souhaites accéder.
Cette possibilité nous est offerte par les variables structurées, ou «types personnalisés».
En gros, il suffira d'indiquer au langage de programmation que nous créons une variable structurée, et d'y inclure des variables de type classique, éventuellement sous la forme de tableaux.
Nous pourrions donc, en suivant l'expemple précédent, créer une structure "personne" qui serait composée de
Les éléments de la structure prendront le nom d'«étiquette» ou de «champs»
Une fois la structure créée, nous disposerons d'un type de variables personnalisé utilisable exactement comme tous les types de base.
Nous pourrions donc déclarer une variable du type "personne" (selon l'exemple), que nous nommerions, par exemple, contact, qui contiendra l'ensemble des informations que nous avons placées dans la structure.
Evidemment, rien ne nous empêche de créer un tableaux du type "personne", nous choisirions alors le contact concerné en sélectionnant son indice.
Nous serons alors en mesure d'accéder à toutes les informations en utilisant la variable contact, ainsi qu'aux informations précises (le nom, le prénom ou tout autre valeur prévue dans la structure) en indiquant l'étiquette de la structure à laquelle on souhaite accéder, en précisant d'abord la variable (contact), suivie d'un point (.), lui même suivi du nom de l'étiquette précise à laquellenous souhaitons accéder.
contact.prenom nous permettrait donc d'accéder à la valeur du prénom de notre contact.
Si contact devait être un tableau, nous sélectionnerions le contact concerné grâce à son indice dans le tableau, et nous accederions à ses informations précises exactement de la même manière.
Nous pourrions même, si le besoin s'en faisait sentir, utiliser cette structure comme un type de base dans une autre structure.
De cette manière, si l'on doit être en mesure de gérer, par exemple, des contacts simples, des clients et des fournisseurs, il y a une série d'informations qui se ressemblent étrangement:
Nous trouverions le nom, le prénom, le téléphone et l'adresse dans les trois catégories.
Nous pourrions donc créer une première structure reprenant ces informations, que nous nommerions, par exemple, logiquement identite, puis créer une structure pour chacune des catégories:
Nous pourrions alors déclarer, selon les besoins, des variables de type "identite", "contact", "client" et "fournisseur".
Nous serions alors en mesure de permettre à l'utilisateur de fournir les valeurs pour la variable de type identite et d'utiliser ces valeurs pour les placer, au choix, dans les valeurs correspondantes pour un contact, un client ou un fournisseur.
Il est donc parfaitment envisageable de créer, un peu à la manière des poupées russes, une structure qui contiendrait plusieurs structures plus petites, qui contiendraient elles-meme plusieurs structures, qui contiendraient(etc)…
Et, bien évidemment, chaque étiquette d'une structure donnée pourrait être un tableau de la structure plus petite qui sert de type de base…
Il est fort vraissemblable que les différents langages n'acceptent qu'un nombre limité d'imbrications de structures, mais il est relativement malaisé de trouver de la documentation cohérente sur le sujet.
L'un dans l'autre, il sera cependant parfaitement possible de prévoir un nombre d'imbrications très largement suffisant pour tous les usages que vous pourriez envisager (l'une des limites que j'ai trouvée pour un langage particulier était de 15 imbrications maximum (erreur à la 16eme))
Il faudra cependant bien prendre conscience du fait qu'une structure imbriquée sur 15 niveaux risque de prendre une place considérable en mémoire.
L'accès à un élément donné se fera de la manière la plus simple qui soit, en suivant d'étiquette en étiquette le chemin qui permet d'arriver à la donnée que l'on recherche.
Evidemment, si l'une des étiquette nous amène à un tableaux, l'indice de l'élément du tableau auquel on veut accéder devra être fourni…
Un code ressemblant à
variable[4].etiquette1.etiquette2[3].etiquette3.etiquette4.etiquette5[3]
n'aurait donc rien de très étonnant dans un contexte donné (et surtout avec les strucutres correspondantes)
Comme je l'ai indiqué, il y a parfaitement moyen de déclarer un tableaux du type d'une structure que l'on a créée.
Il est donc parfaitement envisageable de créer un tableau contenant… 1 000 éléments de type fournisseur.
Cependant, les risques et problèmes liés à l'utilisation de tableaux déclarés statiquement restent fatalement présents lorsque l'on déclare un tableau basé sur une structure.
Pour palier à ce problème, il faudra passer par une gestion dynamique des éléments déclarés, ce dont on parlera un peu plus loin
Copyright (©) 2005 (Philippe Dunski)
Ce cours est libre, vous pouvez le redistribuer et/ou le modifier selon les termes de la Licence Publique Générale GNU publiée par la Free Software Foundation (version 2 ou bien toute autre version ultérieure choisie par vous).
Ce cours est distribué car potentiellement utile, mais SANS AUCUNE GARANTIE, ni explicite ni implicite, y compris les garanties de commercialisation ou d'adaptation dans un but spécifique. Reportez-vous à la Licence Publique Générale GNU pour plus de détails.
Cependant, l'auteur apprécierait grandement que vous lui fassiez part de toute modification apportée à son contnu
Vous pouvez le contacter par mail à l'adresse koala01@free.fr
Vous pouvez trouver une adaptation française de la licence GNU/GPL à l'URL http://www.linux-france.org/article/these/gpl.html
