Discussion :

[JJJJJ]

Bonjour,

je tombe sur un problème de programmation qui semble pourtant très simple. Il y a certainement une solution évidente qui m'échappe malheureusement.
Il serait trop difficile d'expliquer le contexte et le programme compliqué et volumineux dans son ensemble. J'ai donc mis la question sous une forme réduite au maximum, de telle sorte qu'elle soit posée comme "un cas d'école" :
Il faut savoir qu'un nombre important d'array sont déclarés avec des noms divers.
A certain point du déroulement du programme, on veut d'afficher à l'écran la valeur numérique de l'élément de rang 4 (par exemple) de l'array dont le nom est entré au clavier par l'utilisateur.
La question ne porte pas sur la vérification de l'existence, ou non, de l'array dont l'utilisateur donne le nom.
Voilà comment la vraie question se pose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
var
    S:string;
    { ... déclaration des différents array de real ... }
 
begin
       { ... partie initiale dans laquelle les valeurs numériques des éléments des différents array sont calculées ... }
       write('Tappez le nom de l''array : ');
       readln(S);
       writeln(S[4]);       {cette syntaxe ne marche évidemment pas car il n'existe pas d'array dont le nom serait S}

Si l'utilisateur a entré par exemple : Vect, il faudrait que l'instruction soit : writeln(Vect[4]) , car l'array Vect existe. Mais cette instruction correcte ne peut pas être écrite en programme, puisqu'on ne sait pas à l'avance quel sera le nom entré au clavier par l'utilisateur.
Comment faire ?

[droggo]

Koe,

La question contient pratique ment la réponse.

Puisque ton programme est "compliqué et volumineux", je suppose que tu connais le Pascal, et tu as bien vu qu'il n'y a pas de moyen standard.

Ton problème étant "avec un nom entré au clavier, afficher un élément du tableau portant ce nom dans le programme".

La réponse me semble évidente, quelques secondes de réflexion (au plus) devraient suffire.

[ALT]

En ce qui me concerne, je passerais le tableau comme paramètre (par variable) d'une procédure.
Non ?

[krachik]

Bonjour
Mais son soucis c'est pas plutôt faire une correspondance entre ses différents variables tableaux déclarées dans le programme et le nom que l'utilisateur saisira?

[ALT]

Pour ça, il y a plein de méthodes.

Donc, à lui de choisir celle qui lui convient.
À moins que ce soit précisément ça sa question...

[droggo]

Hai,

Donc, à lui de choisir celle qui lui convient.
À moins que ce soit précisément ça sa question...

Oui, c'est ça la question, ou alors c'est mal exprimé.

Pour ça, il y a plein de méthodes.

C'est bien pour ça que j'ai répondu que ça me paraissait évident, car une courte réflexion doit déboucher sur au moins une d'entre elles, même si ce n'est pas la meilleure.

[CapJack]

Toute solution passera nécessairement par une association entre une liste de chaînes représentant les noms des tableaux, et les tableaux eux-mêmes, qui d'ailleurs n'ont pas forcément à avoir le même identificateur que leur nom "public" mis à disposition de l'utilisateur. On peut coder ça en "dur" avec une batterie de "if then else", ou avec un tableau, ou pourquoi pas avec un objet...

Tous ces tableaux sont-ils de même type, ont-ils le même nombre d'éléments ?

[JJJJJ]

Bonjour,

et merci à tous pour avoir pris le temps de répondre, même lorsque c'est plutôt humoristique, du genre :
<< La réponse me semble évidente, quelques secondes de réflexion (au plus) devraient suffire >>
La suggestion de "ALT" :
<< En ce qui me concerne, je passerais le tableau comme paramètre (par variable) d'une procédure>>
est en effet une méthode que j'ai utilisée. Mais elle est problématique pour une routine appelée à être utilisée dans des programmes divers. Les tableaux sont bien de même type, mais ils n'ont pas tous le même nombre d'éléments.
(Ceci pour répondre à la question posée par CapJack).
Je comprends le point de vue de CapJack lorsqu'il écrit :
<<Toute solution passera nécessairement par une association entre une liste de chaînes représentant les noms des tableaux, et les tableaux eux-mêmes, qui d'ailleurs n'ont pas forcément à avoir le même identificateur que leur nom "public" mis à disposition de l'utilisateur. On peut coder ça en "dur" avec une batterie de "if then else", ...>>
Mais alors, cela devient une usine à gaz. Je me demandais s'il ne pouvait pas y avoir une méthode simple, permétant de créer une procédure d'usage général, par exemple comme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Procedure SolveSystem(S:string;n:integer);

Le string S donnant le nom du tableau sur lequel les calculs vont être effectués. L'integer n donnant le nombre d'éléments du tableau et "SolveSystem" étant le nom de la procédure qui exécute les calculs sur le tableau désigné. Avec à la fin de la procédure, les résultats se trouvant dans ce même tableau en écrasant les valeurs qu'il contenait initialement (La liste des tableaux est définie au niveau du programme principal et non dans la procédure. Au moment de l'écriture de la procédure, on ne connait ni le nombre de ces tableaux, ni leur dimension, ni leurs différents noms. On sait que les éléments sont toujours des real).
Ceci dit, je doute de plus en plus que ce soit simplement possible. Si non, je n'aurais pas posé la question pour avoir confirmation ou, sait-on jamais, une bonne idée.

[JJJJJ]

D'une façon moins générale et m'adressant plus précisément à ALT qui pense à <<plein de méthodes>>, je n'en demande pas tant. Une seule me suffirait. Mais pour clarifier la question, se serait bien que cette méthode apparaisse noir sur blanc, écrite dans le listing joint à la question initiale (Hier 10h33).
De cette façon je pourais voir ce qui cloche dans la façon dont ma question est interprétée (en effet, elle est peut-être mal formulée, mais je ne vois pas en quoi).

[Alcatîz]

Bonjour,

Il y a moyen d'éviter l'écueil de la taille du tableau en déclarant un type de tableau universel.
Voici comment j'envisagerais ton problème : je créerais une liste chaînée comprenant les noms, tailles et adresses de tous les tableaux à traiter.
La procédure SolveSystem recevrait simplement le nom du tableau à traiter, rechercherait celui-ci dans la liste et, s'il existe, lui appliquerait le traitement via le type de tableau universel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
43
44
45
46
47
Type (* Type de tableau universel *)
     tTabUniversel = Array [0..0] of Real;
     pTabUniversel = ^tTabUniversel;
 
     (* Liste chaînée des propriétés de tous les tableaux *)
     tRecTab = Record
                 Nom : String [15];
                 Longueur : Integer;
                 Tableau : Pointer;
               end;
     pListRecTab = ^tListRecTab;
     tListRecTab = Record
                     RecTab : tRecTab;
                     Next : pListRecTab;
                   end;
 
Const (* Tête de liste des tableaux *)
      pHeadListRecTab : pListRecTab = Nil;
 
Procedure SolveSystem (S : String; n : Integer);
(* Application d'un traitement sur le tableau dont le nom
   est donné par S. Le traitement est la mise à 0 du
   n.ème élément du tableau (c'est juste un exemple) *)
Var p : pListRecTab;
    Found : Boolean;
Begin
  (* Recherche du nom dans la liste des tableaux *)
  Found := False;
  p := pHeadListRecTab;
  while (p <> Nil) and not Found do
    if p^.RecTab.Nom = S
       then
         begin
           Found := True;
           (* Application du traitement sur le tableau trouvé *)
           if n <= p^.RecTab.Longueur
              then
                pTabUniversel(p^.RecTab.Tableau)^[n] := 0
              else   (* Au-delà de la taille du tableau *)
                WriteLn('Erreur : au-delà de la taille du tableau');
         end
       else
         p := p^.Next;
  if not Found
     then   (* Le tableau n'existe pas *)
       WriteLn('Erreur : tableau inexistant');
End;

Je précise que je n'ai pas testé à l'exécution mais ça compile en tout cas.

[M.Dlb]

+1 sur Alcatîz, j'aurai fait exactement pareil Après à toi de populer ta liste de façon intelligente, en associant bien un nom de tableau à chaque objet. La recherche se fait ensuite sur le nom du tableau...

[darrylsite]

Bonjour,

Il y a moyen d'éviter l'écueil de la taille du tableau en déclarant un type de tableau universel.
Voici comment j'envisagerais ton problème : je créerais une liste chaînée comprenant les noms, tailles et adresses de tous les tableaux à traiter.
La procédure SolveSystem recevrait simplement le nom du tableau à traiter, rechercherait celui-ci dans la liste et, s'il existe, lui appliquerait le traitement via le type de tableau universel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
43
44
45
46
47
Type (* Type de tableau universel *)
     tTabUniversel = Array [0..0] of Real;
     pTabUniversel = ^tTabUniversel;
 
     (* Liste chaînée des propriétés de tous les tableaux *)
     tRecTab = Record
                 Nom : String [15];
                 Longueur : Integer;
                 Tableau : Pointer;
               end;
     pListRecTab = ^tListRecTab;
     tListRecTab = Record
                     RecTab : tRecTab;
                     Next : pListRecTab;
                   end;
 
Const (* Tête de liste des tableaux *)
      pHeadListRecTab : pListRecTab = Nil;
 
Procedure SolveSystem (S : String; n : Integer);
(* Application d'un traitement sur le tableau dont le nom
   est donné par S. Le traitement est la mise à 0 du
   n.ème élément du tableau (c'est juste un exemple) *)
Var p : pListRecTab;
    Found : Boolean;
Begin
  (* Recherche du nom dans la liste des tableaux *)
  Found := False;
  p := pHeadListRecTab;
  while (p <> Nil) and not Found do
    if p^.RecTab.Nom = S
       then
         begin
           Found := True;
           (* Application du traitement sur le tableau trouvé *)
           if n <= p^.RecTab.Longueur
              then
                pTabUniversel(p^.RecTab.Tableau)^[n] := 0
              else   (* Au-delà de la taille du tableau *)
                WriteLn('Erreur : au-delà de la taille du tableau');
         end
       else
         p := p^.Next;
  if not Found
     then   (* Le tableau n'existe pas *)
       WriteLn('Erreur : tableau inexistant');
End;

Je précise que je n'ai pas testé à l'exécution mais ça compile en tout cas.

++Alcatiz. MAis je crois qu'il y a un os :

tTabUniversel = Array [0..0] of Real;

[droggo]

Koi,

++Alcatiz. MAis je crois qu'il y a un os :

tTabUniversel = Array [0..0] of Real;

Non, c'est parfaitement légal, c'est un tableau de 1 élément (ça ne sert à rien comme ça, mais pour évolution future, ça peut être utile ).

[CapJack]

Un point de plus à mister Metoo. Je voulais poster une solution équivalente à celle d'Alcatîz.

La VCL de Delphi utilise aussi (enfin autrefois, les choses changent) une syntaxe du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
type PTableau = ^TTableau;
     TTableau = array[0..Maxint div SizeOf(Double] of Double;

C'est plus satisfaisant pour l'esprit, mais le résultat sera le même.

[M.Dlb]

Koi,

Non, c'est parfaitement légal, c'est un tableau de 1 élément (ça ne sert à rien comme ça, mais pour évolution future, ça peut être utile ).

Non c'est surtout pour dire que le type pTabUniversel est de type "pointeur sur tableau de réel" dont on ne connait pas la longueur. Ca pointe au début de l'adresse mémoire du tableau, et on peut y accéder comme un tableau. Par exemple (dans le code plus bas) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pTabUniversel(p^.RecTab.Tableau)^[n] := 0

[droggo]

Sao,

Non c'est surtout pour dire que le type pTabUniversel est de type "pointeur sur tableau de réel" dont on ne connait pas la longueur. Ca pointe au début de l'adresse mémoire du tableau, et on peut y accéder comme un tableau. Par exemple (dans le code plus bas) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pTabUniversel(p^.RecTab.Tableau)^[n] := 0

Oui, ça peut également servir à ça.

[JJJJJ]

Bonjour,

les réponses suffisent pour que me sois fait une opinion. Je vais en rester là sur ce problème.
Merci aux intervenants (sans oublier celui qui a remplacé le titre initial du sujet par une phrase beaucoup plus explicite).

[ALT]

Dans le cas de tableaux de tailles différentes, je pensais aussi à un pointeur sur un tableau sans dimension :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
program tableaux;
 
type TTab=array of string;
     PTab=^TTab;
 
var tab:TTab;
 
procedure traitement (pt:ptab);
begin
...
end;
 
begin
    traitement(@tab);
end.