Discussion :

[Webistory]

Bonjour,

dans le cadre de mon projet universitaire, j'ai choisi de réaliser une calculatrice en 2D.
Voici quelques explications :
Vous avez déjà sans doute entendu parlé de la notation polonaise ? J'ai choisi de réaliser une calculatrice en notation classique, c'est à dire à qui il suffit de rentrer une ligne d'opérations et qui gérera elle-même les priorités, pour cela j'utiliserai une pile d'entier.
Je procède par étapes, et pour l'instant je suppose que les entrées sont :
soit des entiers
soit un '*'
soit un '+'
soit un '='
Je suis donc arrivé à ce bout de code, mais il y a deux trois erreurs que je n'arrive pas à trouver, et j'aimerai avoir votre concours pour cela.
Merci d'avance pour toute réponse !

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
program calculatrice;
 
uses crt;
const N=100;
 
type poly = array[0..N] of integer;
 
type pile = record
      elements : array[1..N] of poly;
      position : integer;
   end;
 
 
 
var i,m:integer;
    T:pile;
    carcour,choix,a,b:char;
    p,q:poly;
 
 procedure empiler(var T:pile;var n:poly);
  begin
   T.elements[T.position+1]:=n;
   T.position:=T.position+1;
  end;
 
 
 procedure depiler(var T:pile; var res:poly);
   begin
   T.position:=T.position-1;
   res:=T.elements[T.position+1];
  end;
 
 function pilevide(T:pile):boolean;
  begin
   if T.position=0
   then pilevide:=true
   else pilevide:=false;
  end;
 
 procedure sommet(var T:pile; var res:poly);
  begin
   res:=T.elements[T.position];
  end;
 
 procedure evaluation(var T:pile);
  var x,y,op:poly;
  begin
   while T.position<>1 do
    begin
     depiler(T,x);
     depiler(T,op);
     depiler(T,y);
     if op[0]=-2
     then empiler(T,x+y);
     if op[0]=-1
     then empiler(T,x*y);
    end;
  end;
 
procedure ad_poly(p,q:poly; var resul: poly);
 begin
  for i:=1 to N do
   resul[i]:=p[i]+q[i];
 end;
 
procedure mult_poly(p, q : poly; var res : poly);
var : tmp : poly;
i, k : integer;
begin
  for k := 0 to N do begin
    for i := 0 to k - 1 do
        tmp[i] := 0;
    for i := k to N do
        tmp[i] := p[i]*q[i-k];
 
        res:= res + tmp;
  end;
end;
 
 
begin
 clrscr;
 
 
writeln('Choisissez ce que vous voulez calculer');
writeln('Pour utiliser la calculatrice simple,.........tapez a');
writeln('Pour la recherche de racines de polyn“mes,....tapez b');
readln(choix);
 
if choix='a' then
begin
 T.position:=0;
 write('Entrez une op‚ration de chiffres positifs finis par un =');
 writeln;
 read(carcour);
 
 while carcour<>'=' do
  begin
   if carcour in ['0'..'9'] then
    m:=ord(carcour)-ord('0');
   if carcour='*' then
    begin
     m:=-1;
     op[0]:=m;
    end;
   if carcour='+' then
    begin
     m:=-2;
     op[0]:=m;
     evaluation(T);
   end;
   empiler(T,m);
   read(carcour);
  end;
 
 evaluation(T);
 
 x:= sommet(T,x);
 
 for i:=1 to T.position do
  write(T.elements[i],' ');
 
 writeln;
 
 if (pilevide(T)=true)
 then writeln('La pile est vide')
 else writeln('La pile n''''est pas vide');
 
 writeln('L''''entier qui se trouve au sommet est:',x);
end;
 
if choix='b' then
 begin
 writeln('Entrez un polynome quelconque');
 read(poly);
 writeln('Entrez deux variables a et b tels que P(a)P(b)<0');
 read(a,b);
 
 
 end;
 
 
 readln;
 readln;
 
end.

[Dr.Who]

mmm pas mal d'erreur, je n'ai pas pus tout corriger ni tester puisque je n'ai pas TP7, mais tu peu voir comment faire un peu mieux :

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
program calculatrice;
 
uses crt;
 
const
  MaxPoly = 100;
  MaxElem = 100;
 
type
  TPoly = object
    Items: array[0..MaxPoly-1] of integer;
    Count: integer;
    procedure Push(const A : integer);
    procedure Pop(var A: integer);
    function First: integer;
    function Last: integer;
    procedure Add(const A: TPoly);
    procedure Subtract(const A: TPoly);
    procedure Multiply(const A: TPoly);
    procedure Divide(const A: TPoly);
    procedure Reset;
  end;
 
type
  TPile = object
    Items    : array[0..MaxElem-1] of TPoly;
    Count    : integer;
    procedure push(const aPoly: TPoly);
    procedure pop(var aPoly: TPoly);
    procedure First(var aPoly: TPoly);
    procedure Last(var aPoly: TPoly);
    procedure Reset;
  end;
 
 
{ TPile }
 
procedure TPile.Reset;
var N : integer;
begin
  Count   := 0;
  for N := 0 to MaxElem-1 do
    Items[N].Reset;
end;
 
procedure TPile.push(const aPoly: TPoly);
begin
  if count < MaxElem then
  begin
    Items[Count] := aPoly;
    inc(Count);
  end;
end;
 
procedure TPile.pop(var aPoly: TPoly);
begin
  if Count > 0 then
  begin
    dec(Count);
    aPoly := Items[Count];
  end;
end;
 
procedure TPile.First(var aPoly: TPoly);
begin
  aPoly := Items[0];
end;
 
procedure TPile.Last(var aPoly: TPoly);
begin
  aPoly := Items[Count-1];
end;
 
 
{ TPoly }
 
procedure TPoly.Add(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] + A[N];
end;
 
procedure TPoly.Divide(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] div A[N];
end;
 
function TPoly.First: integer;
begin
  First := Items[0];
end;
 
function TPoly.Last: integer;
begin
  Last := Items[Count-1];
end;
 
procedure TPoly.Multiply(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] * A[N];
end;
 
procedure TPoly.Pop(var A: integer);
begin
  if Count > 0 then
  begin
    dec(count);
    A := Items[Count];
  end;
end;
 
procedure TPoly.Push(const A: integer);
begin
  if Count < MaxElem then
  begin
    Items[Count] := A;
    inc(Count);
  end;
end;
 
procedure TPoly.Reset;
var N : integer;
begin
  count := 0;
  for N := 0 to MaxPoly-1 do
    Items[N] := 0;
end;
 
procedure TPoly.Subtract(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] - A[N];
end;
 
 
 
 
 
procedure evaluation(var aPile: TPile);
var x, y, op : Tpoly;
begin
  while aPile.count > 0 do
  begin
    aPile.pop(X);
    aPile.pop(OP);
    aPile.pop(Y);
 
    case OP.Items[0] of
      -2 : begin
        X.Add(Y);
        aPile.push(X);
      end;
      -1 : begin
        X.Multiply(Y);
        aPile.push(X);
      end;
    end;
  end;
end;
 
 
procedure addPoly(const P,Q: TPoly; var result: TPoly);
var I : integer;
begin
  for I := 0 to MaxPoly-1 do
   result.Items[i] := p.Items[i] + q.Items[i];
end;
 
procedure mulPoly(const P, Q : TPoly; var result : TPoly);
var tmp : TPoly;
    i, k : integer;
begin
  for k := 0 to MaxPoly-1 do
  begin
    for i := 0 to k-1 do
        tmp.Items[i] := 0;
 
    for i := k to MaxPoly-1 do
        tmp.Items[i] := p.Items[i] * q.Items[i-k];
 
    result := result + tmp; // <-- ??!
  end;
end;
 
 
var
  i,m : integer;
  Pile: TPile;
  carcour, choix, a, b : char;
  P, Q, OP: TPoly;
 
 
begin
  clrscr;
 
 
  writeln('Choisissez ce que vous voulez calculer');
  writeln('Pour utiliser la calculatrice simple,.........tapez a');
  writeln('Pour la recherche de racines de polyn“mes,....tapez b');
  writeln('');
  write('Votre choix : ');
  read(choix);
 
  case choix of
    'a' : begin
      Pile.Reset;
 
      write('Entrez une operation de chiffres positifs finis par un =');
      writeln;
      read(carcour);
 
      while carcour <> '=' do
      begin
        if carcour in ['0'..'9'] then
          m := ord(carcour)-ord('0');
 
        if carcour = '*' then
          OP.Items[0] := -1;
 
        if carcour = '+' then
        begin
          OP.Items[0] := -2;
          evaluation(Pile);
        end;
        Pile.push(m); // <-- ??! M n'est pas TPoly!
        read(carcour);
      end;
 
      evaluation(Pile);
 
      Pile.Last(X); // <-- ??! X n'est pas definit!
 
      for I := 0 to Pile.Count-1 do
        write(Pile.Items[I],' ');
 
      writeln;
 
      if Pile.Count = 0 then
        writeln('La pile est vide')
      else
        writeln('La pile n''est pas vide');
 
      writeln('L''entier qui se trouve au sommet est:', X); // <-- ??! X n'est pas definit
    end;
 
    'b' : begin
      writeln('Entrez un polynome quelconque');
      read(poly); // <-- ??! poly n'est pas definit
 
      writeln('Entrez deux variables a et b tels que P(a)P(b)<0');
      read(a,b);
    end;
    else
      writeln('Erreur de saisie');
  end;
 
  readln;
 
end.

[Webistory]

Merci de ton aide, et désolé du retard. Quand tu me dit 'machin' n'est pas définit, tu veux dire que je ne l'ai pas initialisé c'est ça?? Mais je me perds souvent dans les variables globales ou non, et ce malgré tous les tuto que j'ai pu potasser, je n'ai généralement pas trop de problème pour faire l'algorithme, mais passer à la syntaxe pascal est souvent difficile, enfin, j'ai repris ce que tu m'avais dis, mais il y à certains endroits où je suis littéralement dépassé, je ne sais même pas quoi faire... Peux tu m'aider s'il te plais??

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
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
program calculatrice;
 
uses crt;
 
var X,poly : real;
const
  MaxPoly = 100;
  MaxElem = 100;
 
type
  TPoly = object
    Items: array[0..MaxPoly-1] of integer;
    Count: integer;
    procedure Push(const A : integer);
    procedure Pop(var A: integer);
    function First: integer;
    function Last: integer;
    procedure Add(const A: TPoly);
    procedure Subtract(const A: TPoly);
    procedure Multiply(const A: TPoly);
    procedure Divide(const A: TPoly);
    procedure Reset;
  end;
 
type
  TPile = object
    Items    : array[0..MaxElem-1] of TPoly;
    Count    : integer;
    procedure push(const aPoly: TPoly);
    procedure pop(var aPoly: TPoly);
    procedure First(var aPoly: TPoly);
    procedure Last(var aPoly: TPoly);
    procedure Reset;
  end;
 
 
{ TPile }
 
procedure TPile.Reset;
var N : integer;
begin
  Count   := 0;
  for N := 0 to MaxElem-1 do
    Items[N].Reset;
end;
 
procedure TPile.push(const aPoly: TPoly);
begin
  if count < MaxElem then
  begin
    Items[Count] := aPoly;
    inc(Count);
  end;
end;
 
procedure TPile.pop(var aPoly: TPoly);
begin
  if Count > 0 then
  begin
    dec(Count);
    aPoly := Items[Count];
  end;
end;
 
procedure TPile.First(var aPoly: TPoly);
begin
  aPoly := Items[0];
end;
 
procedure TPile.Last(var aPoly: TPoly);
begin
  aPoly := Items[Count-1];
end;
 
 
{ TPoly }
 
procedure TPoly.Add(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] + A[N]; 
end;
 
procedure TPoly.Divide(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] div A[N];
end;
 
function TPoly.First: integer;
begin
  First := Items[0];
end;
 
function TPoly.Last: integer;
begin
  Last := Items[Count-1];
end;
 
procedure TPoly.Multiply(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] * A[N];
end;
 
procedure TPoly.Pop(var A: integer);
begin
  if Count > 0 then
  begin
    dec(count);
    A := Items[Count];
  end;
end;
 
procedure TPoly.Push(const A: integer);
begin
  if Count < MaxElem then
  begin
    Items[Count] := A;
    inc(Count);
  end;
end;
 
procedure TPoly.Reset;
var N : integer;
begin
  count := 0;
  for N := 0 to MaxPoly-1 do
    Items[N] := 0;
end;
 
procedure TPoly.Subtract(const A: TPoly);
var N : integer;
begin
  for N := 0 to Count - 1 do
    Items[N] := Items[N] - A[N];
end;
 
 
 
 
 
procedure evaluation(var aPile: TPile);
var x, y, op : Tpoly;
begin
  while aPile.count > 0 do
  begin
    aPile.pop(X);
    aPile.pop(OP);
    aPile.pop(Y);
 
    case OP.Items[0] of
      -2 : begin
        X.Add(Y);
        aPile.push(X);
      end;
      -1 : begin
        X.Multiply(Y);
        aPile.push(X);
      end;
    end;
  end;
end;
 
 
procedure addPoly(const P,Q: TPoly; var result: TPoly);
var I : integer;
begin
  for I := 0 to MaxPoly-1 do
   result.Items[i] := p.Items[i] + q.Items[i];
end;
 
procedure mulPoly(const P, Q : TPoly; var result : TPoly);
var tmp : TPoly;
    i, k : integer;
begin
  for k := 0 to MaxPoly-1 do
  begin
    for i := 0 to k-1 do
        tmp.Items[i] := 0;
 
    for i := k to MaxPoly-1 do
        tmp.Items[i] := p.Items[i] * q.Items[i-k];
 
    result := result + tmp.item[i]; // <-- ??! <-- Cela devrait marcher là non?
  end;
end;
 
 
var
  i,m : integer;
  Pile: TPile;
  carcour, choix, a, b : char;
  P, Q, OP: TPoly;
 
 
begin
  clrscr;
 
 
  writeln('Choisissez ce que vous voulez calculer');
  writeln('Pour utiliser la calculatrice simple,.........tapez a');
  writeln('Pour la recherche de racines de polyn“mes,....tapez b');
  writeln('');
  write('Votre choix : ');
  read(choix);
 
  case choix of
    'a' : begin
      Pile.Reset;
 
      write('Entrez une operation de chiffres positifs finis par un =');
      writeln;
      read(carcour);
 
      while carcour <> '=' do
      begin
        if carcour in ['0'..'9'] then
          m := ord(carcour)-ord('0');
 
        if carcour = '*' then
          OP.Items[0] := -1;
 
        if carcour = '+' then
        begin
          OP.Items[0] := -2;
          evaluation(Pile);
        end;
        Pile.push(Tpoly); // <-- ??! M n'est pas TPoly! <-- Je n'ai pas trop compris : je remplace bêtement?
        read(carcour);
      end;
 
      evaluation(Pile);
 
      Pile.Last(X); // <-- ??! X n'est pas definit!<-- définit en tant que variable globale
 
      for I := 0 to Pile.Count-1 do
        write(Pile.Items[I],' ');
 
      writeln;
 
      if Pile.Count = 0 then
        writeln('La pile est vide')
      else
        writeln('La pile n''est pas vide');
 
      writeln('L''entier qui se trouve au sommet est:', X); // <-- ??! X n'est pas definit<-- définit en tant que variable globale
    end;
 
    'b' : begin
      writeln('Entrez un polynome quelconque');
      read(poly); // <-- ??! poly n'est pas definit<-- définit en tant que variable globale
 
      writeln('Entrez deux variables a et b tels que P(a)P(b)<0');
      read(a,b);
    end;
    else
      writeln('Erreur de saisie');
  end;
 
  readln;
 
end.

[Dr.Who]

en fait, tu dois avant tout conventionner ton code.

si tu ne le fais pas, tu sera toujours perdus.

les conventions d'ecriture existe mais on peu créer les siennes. elles permettent une meilleure clarté et lecture analytique du code.


exemple :

des variables globales (préfixe "vg") :

Code :

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

1
2
3
var
  vgX, vgY : integer;
  vgPoly : real;

ici, il nous est plus facile de trouver et voir les variables globales dans le code. attention, il ne faut pas abusé des variables globales, généralement on préfèrera les regrouper au seins de structure.

des constantes globales (préfixe "c") :

Code :

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

1
2
3
4
const
  cXMax = 100;
  cYMax = 100;
  cPolyCount = 200;

ici, on peu différencier facilement les constantes globales des variables globales.
en C/C++ on ecrit généralement ces constantes en majuscule (X_MAX, Y_MAX ...) mais pascal n'étant pas case sensitive un identifiant "X_MAX" sera identique à un autre identifiant "x_max" et provoquera une erreur.


les arguments de procedure (préfixe "a") :

Code :

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

procedure Truc(aX, aY : integer; aPoly: real);

ici, le but est d'avoir des arguments qui se differencie naturellement des variables ou constantes globales. encore une fois, on analyse mieux le code d'une méthode par le nomage correct des arguments. exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
const
  X = 100;
  Y = 100;
 
function truc(X, Y: integer): integer;
begin
  // truc ne peu acceder aux constantes globales X et Y
  // ici les divisions retournerons tout le temps 1 et donc
  // peu importe X et Y, le resultat sera toujours 1. 
  // puisqu'on divise les arguments X et Y par eux mêmes. 
  truc := (X div X) * (Y div Y);
end;

correction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
const
  cX = 100;
  cY = 100;
 
function truc(aX, aY: integer): integer;
begin
  // cette fois, truc peu acceder aux constantes globales cX et cY
  // le resultat ne sera donc plus érroné.
  truc := (aX div cX) * (aY div cY);
end;

arguments constant "a",
arguments var "v"
arguments out "o"
arguments pointeur "p"

Code :

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

procedure Truc(const aX, aY: integer; var vPoly: real; const pPoly: PReal; out oRet: integer);

ici on differencie encore mieux, quels arguments servent au retour de valeur ou servent en lecture seule.
on pourrait également utiliser des préfixes "r", "w" et "rw" pour Read, Write, ReadWrite.
exemple :

Code :

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

procedure Truc(const rX, rY: integer; var rwPoly: real; const rPoly: PReal; out wRet: integer);

une autre façon de faire avec "i" et "o" pour "input", "output" :

Code :

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

procedure Truc(const iX, iY: integer; var ioPoly: real; const iPoly: PReal; out oRet: integer);

nouveau type préfixe "T", pointeur sur type "P" :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
type
  PPoly = ^TPoly;
  TPoly = real;
 
  PIntRec = ^TIntRec;
  TIntRec = record
    X, Y: integer;
  end;
 
  PRealArray = ^TRealArray;
  TRealArray = array[0..n] of real;

ici, T et P nous permettent de differencier facilement les Types et leurs type Pointeur.
cela nous permet d'avoir le champs libre pour les identifiants des variables :

Code :

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

1
2
3
4
5
 
var
  RealArray : TRealArray;
  IntRec : TIntRec;
  ptrPoly : PPoly;

remarque que pour la variable de type PPoly, j'ai utilisé le préfixe "ptr" pour pointeur.


type méthode, préfixe "T" et suffixe "Proc" ou "Func" :

Code :

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

1
2
3
type
  TCallBackProc = procedure (aX, aY: integer; var vRet: integer);
  TCallBackFunc = function (aX, aY: integer): integer;

ici on utilise la convention générale des type (préfixe "T") et une convention en plus pour bien differencier le type procédure du type fonction.
cela permet au developpeur de savoir ce qu'il doit chercher ou créer plus facilement.
en voyant un argument de type TCallBackFunc il cherchera une déclaration de fonction, autrement avec TCallBackProc il cherchera une déclaration de procédure.
le Pascal est l'un des rare langage à posséder deux termes distinct pour differencier les méthodes avec retour (function) et les méthode sans retour (procedure).
C, C++, JavaScript, PHP, VB, etc, ne possèdent qu'un seul terme (function) et qui necessite un retour dit "void" (rien) pour correspondre au terme "procedure" du pascal.
exemple C vers Pascal :

Code :

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

1
2
int Truc(int X, int Y) {} ===> function truc(X,Y: integer): integer;
void Truc(int X, int Y) {} ===> procedure Truc(X, Y: integer);

il n'est pas necessaire d'ajouter des préfixes ou suffixes au identifiant de fonction, de procedure ou de variables locales.
mais il faut faire attention de ne pas "ecraser" un identifiant avec un autre.
Pascal prend la dernière déclaration d'un identifiant comme celle qui doit être.
exemple d'écrasement en chaine :

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 Program; // ecrase le mot clef "program" -> mauvais nom de projet
 
type
  program = integer; // ecrase le mot clef "program" et le nom de projet
 
const
  program = 'bloubli'; // ecrase le type "program"
 
var
  program : program; // double ecrasement par l'identifiant de la variable 
    // et le type "program" précédement écrasé par la constante "program"
 
function Program(const Program: program): program; 
// AOUTCH! impossible à compiler, quadruple écrasement!

correction avec les conventions :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
program MonProgram; // ok
 
type
  TProgram = integer; // ok
 
const
  cProgram = 'bloubli'; // ok
 
var
  vgProgram : TProgram; // ok
 
function ProgramFunc(const aProgram: TProgram): TProgram; // ok

voila comment utiliser l'identifiant "program" sans provoquer d'erreur. d'ailleurs on vois bien comment la colorisation syntaxique se comporte dans l'exemple erroné et l'exemple corrigé. l'exemple visuel parle de lui même.


une fois que tu as compris cela, ton code sera beaucoup plus clair et tu le lira plus facilement.
il sera également plus facile d'y revenir plus tard.

un code mal indenté, mal conventionné et non commenté, est toujours trés démotivant et difficile à maintenir.

voila.

[Dr.Who]

faut vraiment que j'arrête de faire des "cours" plutôt que des réponses "courte".

[Webistory]

Merci de ton cours, qui a l'avantage d'être clair et compréhensible !!
Je pense que j'arriverai à m'en sortir maintenant, je posterai mon code final dès qu'il sera écrit !
A la prochaine, et bonne continuation.

[Dr.Who]

bon courage et bonne chance.

et n'oublie pas, discipline, persévérance!

ce n'est pas pour rien que les dev pascal sont appelés "jedi".

[moha-ali]

Voici le programme :

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
program calculatrice;
 
uses crt;
const N=100;
 
type poly = array[0..N] of integer;
 
type pile = record
      elements : array[1..N] of poly;
      position : integer;
   end;
 
 
 
var i,m:integer;
    T:pile;
    polyn,carcour,choix,a,b:char;
    x,op,p,q:poly;
 
 procedure empiler(var T:pile; n:poly);
  begin
   T.elements[T.position+1]:=n;
   T.position:=T.position+1;
  end;
 
 
 procedure depiler(var T:pile; var res:poly);
   begin
   T.position:=T.position-1;
   res:=T.elements[T.position+1];
  end;
 
 function pilevide(T:pile):boolean;
  begin
   if T.position=0
   then pilevide:=true
   else pilevide:=false;
  end;
 
 procedure sommet(var T:pile;  res:poly);
  begin
   res:=T.elements[T.position];
  end;
 
 procedure evaluation(var T:pile);
  var x,y,s,m,op:poly;i,j :integer;
  begin
   while T.position<>1 do
    begin
     depiler(T,x);
     depiler(T,op);
     depiler(T,y);
     if op[0]=-2
     then  s[i]:=x[i]+y[j];  empiler(T,m);
     if op[0]=-1
     then m[i]:=x[i]*y[j];    empiler(T,m);
    end;
  end;
 
procedure ad_poly(p,q:poly; var resul: poly);
 begin
  for i:=1 to N do
   resul[i]:=p[i]+q[i];
 end;
 
procedure mult_poly(p, q : poly; var res : poly);
var  tmp : poly;
i, k : integer;
begin
  for k := 0 to N do begin
    for i := 0 to k - 1 do
        tmp[i] := 0;
    for i := k to N do
        tmp[i] := p[i]*q[i-k];
 
        res[i] := res[i] + tmp[i] ;
  end;
end;
 
 
begin
 clrscr;
 
 
writeln('Choisissez ce que vous voulez calculer');
writeln('Pour utiliser la calculatrice simple,.........tapez a');
writeln('Pour la recherche de racines de polyn“mes,....tapez b');
readln(choix);
 
if choix='a' then
begin
 T.position:=0;
 write('Entrez une op‚ration de chiffres positifs finis par un =');
 writeln;
 read(carcour);
 
 while carcour<>'=' do
  begin
   if carcour in ['0'..'9'] then
    m:=ord(carcour)-ord('0');
   if carcour='*' then
    begin
     m:=-1;
     op[0]:=m;
    end;
   if carcour='+' then
    begin
     m:=-2;
     op[0]:=m;
     evaluation(T);
   end;
   empiler(T,op);
   read(carcour);
  end;
 
 evaluation(T);
 
 
 
 
 
 if (pilevide(T)=true)
 then writeln('La pile est vide')
 else writeln('La pile n''''est pas vide');
 
 writeln('Lentier qui se trouve au sommet est:');
end;
 
if choix='b' then
 begin
 writeln('Entrez un polynome quelconque');
 read(polyn);
 writeln('Entrez deux variables a et b tels que P(a)P(b)<0');
 read(a,b);
 
 
 end;
 
 
 readln;
 readln;
 
end.
  x[i]:=sommet(T,x);
   for i:=1 to T.position do
  write(T.elements[i],' ');
 
 writeln;