Discussion :

[axelmeunier]

Voilà, bonjours, j'ai un probleme sur l'identification de type

1)=>Comment peut-on déterminer que telle donnée d'un type X est bien du type afin de pouvoir coder des fonctions d'accès spécifiques...
merci
la finalité est l'analyse de courbes de plongé sous-marines où toute les données sont stockées dans un seul tableau d'une ligne et où chaque case correspond à un type

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
 
type plongé = record
   profondeur : integer ;
   durees : time ; {où time est un type horraire déjà définie}
end;
type plongépalié3 = record
   profondeur : integer ;
   durees : time ; 
   paliE3METRE: integer;
end;
type plongépalié6 = record
   profondeur : integer ;
   durees : time ; 
   paliE3METRE: integer;
   paliE6METRE: integer;
end;

Le problème est donc d'analyser les types pour les interpréter différements...

ps: Le problèmes du projet est la place, d'où l'utilisation de type

2)=>Toujours dans un souci de gain de place...ya-t-il un type horaire optimisé dans Pascal de Borland ou faut-il le taper???????

3)=>Qu'elle est le type de donnée le plus léger (en poid) pour exprimer des nombres:shortint????peut être le type Variant ( connais pas sa taille de stockage)

Merci encore...

[Giovanny Temgoua]

1) Je ne pense pas qu'il existe une façon précise de déterminer le type d'une variable mais cependant il existe un moyen de savoir si une opération de lecture sur une variable s'est bien passé (compatibilité de type par exemple) à l'aide de la variable IOResult

2) Je ne pense pas

3) Le type le plus léger en terme de poids est byte (ce qui est assez limité) 0..255 je crois.

[M.Dlb]

Tu peux t'amuser à reconnaître un type en fonction de sa taille en octet, avec la fonction SizeOf()... En espérant que deux types n'ont pas la même taille
En ce qui concerne le type "horaire", il vaut mieux le faire soit même, car Borland fait des types "grand public" avec en général plein de fonctionnalités bien inutiles (ca a "empiré" avec Delphi )...
Le type le plus petit pour des entiers non signés, est le byte, qui va de 0 à 255. Pour les entiers signés, il y a le shortint, qui va de -128 à 127... Y'a aussi le booléen qui est assez sympa en général Variant n'existe pas sous TP (encore un truc de Delphi...)

a+

[axelmeunier]

merci bcp....
Mais le probleme reste important pour la question 1...
Je vous postes demain des esssais de fonctions de reconnaissance de type...

[Alcatîz]

Bonjour !

J'ai du mal à saisir dans quel contexte tu dois détecter le type d'une variable. Le type time que l'on voit dans ton extrait de code t'est-il inconnu ?

Si oui, essaye toujours de voir si les durées ne sont pas codées sur un entier long (avec SizeOf). Dans ce cas, tu as peut-être une chance de les décompacter à l'aide de la procédure UnpackTime.

Le type time est peut-être simplement un enregistrement contenant 2 entiers (1 pour les heures et 1 pour les minutes) ?
En dernier recours, essaye de séparer "à la main" les différents groupes de bits correspondant aux heures, minutes, secondes...

Et si j'ai répondu à côté de la plaque, je suis désolé...

[axelmeunier]

un peu mais merci bcp quand meme...vé tacher d'etre plus precis

voila...
nouveau systeme...
nouveau probleme...
je suis passé sur un type évolutif....
jusque la pas de probleme...
mais j'ai un probleme pour la fonction d'acces...comment on gere les erreurs comme evoquées précédement avec ioresult...
Voila mon code sinon pour vous éclairer...il fera le contraire surement mais je n'en suis qu'au moment des choix de représentation....

ps cf message 1 qui situe Un peu le probleme....stocker des table de plongée avec un manque de place...(un peu comme pour l'expression c'est a faire pour hier...

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
(* Axel Meunier projet algorithmique 2003 2004*)
 
Program projet;
 
Uses Crt, Dos;
 
const tabpali:array [0..363]of byte =(0,0,0,0,0,0,0,0,0,0,
                                      0,0,0,0,0,0,0,0,0,0,
                                      0,0,0,0,0,0,0,0,0,0,
                                      0,0,0,0,0,0,1,0,0,0,
                                      0,0,0,0,0,0,0,0,0,0,
                                      0,0,
                                      0,0,0,0,0,0,0,0,0,0,
                                      0,1,1,1,1,1,1,1,1,1,
                                      1,1,1,1,1,0,0,0,0,0,
                                      0,0,0,0,0,0,0,0,0,0,
                                      1,1,1,1,1,1,1,1,1,0,
                                      0,0,
(*indique le nombre de palie *)       0,0,0,0,0,0,0,0,1,1,
(* 0->pas de palie *)                 1,1,1,1,1,1,1,1,1,1,
(* 1->palie a 3 metres *)             1,0,0,0,0,0,0,0,0,1,
(* 2->palie a 3 et 6 metres *)        1,1,1,1,1,1,1,1,1,0,
(* 3->palie a 3,6 et 9 metres *)      0,0,0,0,0,0,1,1,1,1,
(* 4->palie a 3,6,9 et 12 metres *)   1,1,
(* 5->palie a 3,6,9,12 et 15 metres *)1,1,1,1,1,0,0,0,0,0,
                                      1,1,1,1,1,1,1,1,2,2,
                                      2,2,2,2,0,0,0,1,1,1,
                                      1,1,1,1,2,2,2,2,2,2,
                                      2,2,0,0,1,1,1,1,1,2,
                                      2,2,
                                      2,2,2,0,0,1,1,1,1,1,
                                      2,2,2,2,2,2,2,0,0,1,
                                      1,1,2,2,2,2,2,2,3,3,
                                      3,0,1,1,1,2,2,2,2,2,
                                      2,3,3,3,3,0,1,1,2,2,
                                      2,2,
                                      2,3,3,3,3,3,3,0,1,1,
                                      2,2,2,2,3,3,3,3,3,0,
                                      1,2,2,2,2,3,3,3,3,3,
                                      4,0,1,2,2,2,3,3,3,3,
                                      4,4,4,1,1,2,2,3,3,3,
                                      3,4,
                                      4,4,1,2,2,3,3,3,3,4,
                                      4,4,4,1,2,2,3,3,3,4,
                                      4,4,4,4,1,2,3,3,3,4,
                                      4,4,4,5,5,1,2,3,3,3,
                                      4,4,4,5,5,5,1,2,3,1,
                                      2,3);
 
type pal = record
 
      H : byte;        {ne pas modifier et faire un type conditionnel...vaut pas le coup}
      M : byte;
     end;
     {definition du type qui servira pour les donnees de type temp dans le
     type table: ne prend pas encompte les sec}
(* prevoir fonction de conversion pal->hor *)
 
     hor = record
      H : byte;
      M : byte;
      S : byte;
     end;
     {definition du type qui servira pour les donnees de type temp dans le
     program}
 
 
     donnee = record
       Pro : byte;
       Dur : pal;                        {prevoir fonction de normalisation du type}
       Res : char;                       (*faire de meme pour le type hor et pal*)
       case j:byte of
        0:();
        1:(Pal31 : pal);
        2:(Pal32,Pal62 : pal);
        (*il en manque *)
       end;
     tabMN90 = array[0..363] of donnee;
 
 
var   t0,t : hor ; {variables pour le temps A t=0 et a l'instant T}
      p,pmax : byte;{variables pour la profondeur au temps T et la profondeur max atteinte}
      mn90   : tabmn90;
      x : donnee;
      option, i(* enlever i car  il est juste pour le mode diagnostique et est une redondance
       du i de la procedure chargtabmn90*) : integer;
      stop :boolean;
 
(********************************************)
(*       procedure menu                     *)
(********************************************)
 
Procedure Menu(var Choix:Integer);
 
Begin
   Choix := 0;
   Repeat
     Writeln('1) Mode diagnostique.');
     Writeln('2) charger le tableau');
     writeln('3) afficher le tableau de maniere synthetique');
     writeln('4) ');
     Writeln('5) Quitter.');
     write('choix : ');
     Read(Choix);
   Until Choix in [1..5];
End;
 
 
(********************************************)
(*         procedure  chargtabmn90          *)
(********************************************)
 
procedure chargtabmn90( var tab:tabmn90);
 
var i : integer; (* compteur ou 0<i<363 et correspond … chaque du tab *)
                 (*on l'utilise car le tableau est plus facile a rentrer*)
                 (* comme ca...*)
begin
 for i:=0 to 2 do
 begin                                             {faire des procedures}
  with mn90[i] do
   begin
   case i of
    0..9   :  pro := 6;
    10..21 :  pro := 21;
    (*chercher dans cette voie *)
    end;
   with dur do
    case i of
     0,10 (* il en manque *) : begin m := 15;
                                    h := 0;
                                end;
     1,11  (* il en manque *): begin m := 30;
                                     h := 0;
                                end;
     2,12 (*il en manque *) : m := 45;
    end;                      {pas besoin de h:=0 cf mode diagnostique!!!}
   case i of
     0,38(*il en manque *) : res := 'a';
     1   (*il en manque *) : res := 'b';
     2   (*il en manque *) : res := 'c';
       (*chercher dans cette voie *)
    end;
   j:=tabpali[i];
  end;
 end;
 
 
 
 
end;
 
 
 
(********************************************)
(*         procedure affitableau(mn90)      *)
(********************************************)
 
procedure affitableau (var tab:tabmn90);
var i : integer;
begin
 for i := 0 to 2 do
   with mn90[i] do
   writeln(pro,dur.h,dur.m,res);
end;
 
(********************************************)
(*             Programme principal          *)
(********************************************)
 
Begin
 
    clrscr;
    writeln('Programe de plong‚e par Axel Meunier');
    Repeat
    Menu(Option);
    Case Option of
      1 : writeln(mn90[2].dur.h);
 
      {writeln('rien dans ce mode')}
      2 : chargtabmn90(mn90);
      3 : affitableau(mn90);
      5 : Stop := True;
       End;
  Until Stop;
 
 
 
 
 
end.

[M.Dlb]

Oh le beau code....
Pour IOResult, pas la peine de s'exciter sur les couleurs, il suffit de faire une recherche sur le forum, y'a eu récemment tout un topo là dessus....

a+

[axelmeunier]

non, je ne m'exitais pas sur les couleur...c'etait pour synthétiser ce que je voulais et que vous ayez pas a tout lire...
Merci

[Giovanny Temgoua]

pour utiliser IOResult,

Code :

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

1
2
3
4
5
6
 
{I-}
(* Opération dont on veut savoir si elle a été réussie ou non *)
{I+}
if IOResult = 0 then ... (* Si opération réussie *)
else ...

[Eric Sigoillot]

Si jamais tu utilises Delphi, alors pour savoir ce qu'un type contient, sers-toi du type Variant associé à la fonction VarType.

Pour les classes, il faut se servir de l'opérateur is.

Pour le type date/heure, sous Delphi encore une fois, c'est TDateType.

Et pour en finir avec Delphi, tu peux gérer les erreur d'E/S avec des blocs try...except...end;.

A+

[axelmeunier]

merci a tous mais le probleme est reglé....
j'ai completement changé ma manière de voire les choses et je suis passé a qlq chose de beaucoup plus simple.....encore merci