bonjour
je voudrais savoir SVP comment changer la valeur d'une constante
ex:
pour , adapter la "const" au nombre d'enregistrements d'un fichier , en plus ou en moinsCode:const longueur=300;
merci.
Version imprimable
bonjour
je voudrais savoir SVP comment changer la valeur d'une constante
ex:
pour , adapter la "const" au nombre d'enregistrements d'un fichier , en plus ou en moinsCode:const longueur=300;
merci.
:salut:
Par définition, une constante ne varie pas ;) :mouarf: !
Tu n'as qu'a remplacer ta constante par une variable !
Bonjour.
Il se trouve que, sous Turbo Pascal, une constante peut être modifiée par le programme à la condition que ce soit une constante typée.
Citation du manuel Turbo-Pascal :
" Les constantes typées peuvent être comparées à des variables initialisées, c'est-à-dire des variables dont la valeur est déjà définie avant tout premier accès. "
Exemple :
Const longueur : integer = 300 ;
salut, je ne sais pas si cette methode fonctionne en TP :
cas 1 :
nous avons un tableau array[0..Longueur-1] of ...
et la constante Longueur = 300
mais nous voulons que cette longueur puisse être changée durant l'execution.
problématique :
une constante peut être changé grace aux commutateur $J+/- (constante typée affectable)
mais le type tableau utilisant "Longueur" ne sera pas réalloué avec la nouvelle valeur.Code:
1
2
3
4
5 {$J+} const Longueur : integer = 300; {$J-}
solution 1 :
utilisation d'un tableau dynamique
solution 2 :
utilisation d'un pointeur tableau
Code:
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 unit Arrays; interface type PIntArray = ^IntArray; IntArray = packed array[0..0] of Integer; TIntArray = object Items : PIntArray; Capacity : integer; Count : integer; procedure Create(const aSize: integer); procedure Destroy; procedure Resize(const aSize: integer); function Add(const aValue: integer): integer; overload; procedure Add(const aValues: array of integer); overload; procedure Delete(const aIndex: integer); procedure Exchange(const aIndex1, aIndex2: integer); overload; procedure Exchange(const aIndexs: array of integer); overload; procedure Fill(const aValue: integer); overload; procedure Fill(const aRandMin, aRandMax: integer); overload; procedure Fill(const aFrom, aTo: integer; const aValue: integer); overload; procedure Insert(const aIndex: integer; const aValue: integer); procedure WriteOut; end; implementation { TIntArray } procedure TIntArray.Fill(const aValue: integer); var N : integer; begin for N := 0 to Count-1 do Items[N] := aValue; end; procedure TIntArray.Fill(const aFrom, aTo: integer; const aValue: integer); var N : integer; begin for N := aFrom to aTo do Items[N] := aValue; end; procedure TIntArray.Fill(const aRandMin, aRandMax: integer); var N : integer; begin for N := 0 to Count-1 do Items[N] := aRandMin + Random(aRandMax-aRandMin); end; procedure TIntArray.Insert(const aIndex: integer; const aValue: integer); begin Resize(Count+1); Move(Items[aIndex], Items[aIndex+1], (Count-aIndex) shl 2); Items[aIndex] := aValue; end; procedure TIntArray.Resize(const aSize: integer); begin Capacity := aSize shl 2; Count := aSize; ReAllocMem(Items, Capacity); end; procedure TIntArray.WriteOut; var N, H : integer; begin H := Count-1; write('[',Count,'] : ('); for N := 0 to H do begin Write(Items[N]); if N < H then Write(', '); end; writeln(')'); end; procedure TIntArray.Delete(const aIndex: integer); begin Move(Items[aIndex+1], Items[aIndex], (Count-aIndex) shl 2); Resize(Count-1); end; procedure TIntArray.Destroy; begin FreeMem(Items, Capacity); Capacity := 0; Count := 0; Items := nil; end; procedure TIntArray.Exchange(const aIndexs: array of integer); var N : integer; T : integer; begin for N := 0 to High(aIndexs)-1 do begin T := Items[aIndexs[N]]; Items[aIndexs[N]] := Items[aIndexs[N+1]]; Items[aIndexs[N+1]] := T; end; end; procedure TIntArray.Exchange(const aIndex1, aIndex2: integer); var T : integer; begin T := Items[aIndex1]; Items[aIndex1] := Items[aIndex2]; Items[aIndex2] := T; end; function TIntArray.Add(const aValue: integer): integer; var R : integer; begin R := Count; Resize(R + 1); Items[R] := aValue; Add := R; end; procedure TIntArray.Add(const aValues: array of integer); var R, N, H : integer; begin R := Count; H := High(aValues); Resize(Count + H + 1); for N := 0 to H do Items[R+N] := aValues[N]; end; procedure TIntArray.Create(const aSize: integer); begin if Items <> nil then Destroy; Capacity := aSize shl 2; Count := aSize; Items := AllocMem(Capacity); end; end.
Bonjour et merci à tous pour les réponses
voici où j'en suis ,
le programme s'arrête à la première affectation de "longueur" avec l'erreur 133Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14 type lco=longint; {donRang} l10=string[10]; {donDate} l12=string[12]; {donCase} const longueur : word = 500; {Error 133: Cannot evaluate this expression}. type donnee=record donRang :array[1..longueur] of lco; donDate :array[1..longueur] of l10; donCase :array[1..longueur] of l12; end; var donnees :^donnee;
le commutateur n'est pas acceptéCode:{$J+}
mario
a toi de completer :
Code:
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 type TRang = longint; {donRang} TDate = string[10]; {donDate} TCase = string[12]; {donCase} const SizeOfRang = SizeOf(TRang); SizeOfDate = SizeOf(TDate); SizeOfCase = SizeOf(TCase); type PRangs = ^TRangs; TRangs = packed array[0..0] of TRang; PDates = ^TDates; TDates = packed array[0..0] of TDate; PCases = ^TCases; TCases = packed array[0..0] of TCase; type PData = ^TData; TData = object Rangs : PRangs; CountRangs : integer; Dates : PDates; CountDates : integer; Cases : PCases; CountCases : integer; procedure SetSize(const aSize: integer); procedure SetSizeRangs(const aSize: integer); procedure SetSizeDates(const aSize: integer); procedure SetSizeCases(const aSize: integer); procedure Resize(const aSize: integer); procedure ResizeRangs(const aSize: integer); procedure ResizeDates(const aSize: integer); procedure ResizeCases(const aSize: integer); procedure Release; procedure ReleaseRangs; procedure ReleaseDates; procedure ReleaseCases; end; { TData } procedure TData.Release; begin FreeMem(Rangs, CountRangs * SizeOfRang); CountRangs := 0; Rangs := nil; FreeMem(Dates, CountDates * SizeOfDate); CountDates := 0; Dates := nil; FreeMem(Cases, CountCases * SizeofCase); CountCases := 0; Cases := nil; end; procedure TData.ReleaseCases; begin FreeMem(Cases, CountCases * SizeofCase); CountCases := 0; Cases := nil; end; procedure TData.ReleaseDates; begin FreeMem(Dates, CountDates * SizeOfDate); CountDates := 0; Dates := nil; end; procedure TData.ReleaseRangs; begin FreeMem(Rangs, CountRangs * SizeOfRang); CountRangs := 0; Rangs := nil; end; procedure TData.Resize(const aSize: integer); begin CountRangs := aSize; ReAllocMem(Rangs, aSize * SizeOfRang); CountDates := aSize; ReAllocMem(Dates, aSize * SizeOfDate); CountCases := aSize; ReAllocMem(Cases, aSize * SizeOfCase); end; procedure TData.ResizeCases(const aSize: integer); begin CountCases := aSize; ReAllocMem(Cases, aSize * SizeOfCase); end; procedure TData.ResizeDates(const aSize: integer); begin CountDates := aSize; ReAllocMem(Dates, aSize * SizeOfDate); end; procedure TData.ResizeRangs(const aSize: integer); begin CountRangs := aSize; ReAllocMem(Rangs, aSize * SizeOfRang); end; procedure TData.SetSize(const aSize: integer); begin Release; CountRangs := aSize; Rangs := AllocMem(aSize * SizeOfRang); CountDates := aSize; Dates := AllocMem(aSize * SizeOfDate); CountCases := aSize; Cases := AllocMem(aSize * SizeOfCase); end; procedure TData.SetSizeCases(const aSize: integer); begin ReleaseCases; CountCases := aSize; Cases := AllocMem(aSize * SizeOfCase); end; procedure TData.SetSizeDates(const aSize: integer); begin ReleaseDates; CountDates := aSize; Dates := AllocMem(aSize * SizeOfDate); end; procedure TData.SetSizeRangs(const aSize: integer); begin ReleaseRangs; CountRangs := aSize; Rangs := AllocMem(aSize * SizeOfRang); end;
:ccool:
comme quoi, croyances et légendes commune est reine d'absurdité linguistique alors que même le françois académique s'y trompe bougrement.
donc autant dire que il n'est pas académiquement incorrect de dire "au temps" et il n'est pas étymologiquement incorrect de dire "autant".
donc il est clair de se dire qu'il est temps de laisser la place d'au temps à celle d'autant.
pour changer faisons dans la version entomologique:
au taon pour moi.
merci pour l'article.
Bonjour
merci pour le code , mais il bloque à
que j'ai remplacé par GETMEMCode:ReAllocMem
et à
que je n'arrive pas à adapterCode:AllocMem
PS : je travaille avec TP7
je continue la recherche
erf...
AllocMem -> GetMem
FreeMem est present dans TP7 si je me trompe pas.
ReAllocMem par contre ... il faudra la créer.
je voulais l'extraire de delphi ... mais c'est un peu complexe en fait puisque dépendant du gestionnaire de memoire.
chercher dans l'aide pour une fonction équivalente sinon :
fait de tête, surement à corriger :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 procedure ReAllocMem(var Ptr: Pointer; const oldSize, NewSize: integer); var T : pointer; M : integer; begin if OldSize > NewSize then M := NewSize else M := OldSize; T := GetMem(NewSize); move(Ptr^, T^, M); FreeMem(ptr, oldSize); ptr := T; end;
Bonjour
ça ne fonctionne pas
GetMem demande 2 paramètres c'est pour ça que j'avais su le placer
c'est AllocMem qui pose problème car GetMem(ptr,var) demande 2 paramètresCitation:
que j'ai remplacé par GETMEMCode:ReAllocMem
merciCitation:
que je n'arrive pas à adapterCode:AllocMem
J'ai pas lu tout les posts, mais le peu j'ai pu lire me laisse comprendre que l'on essaie d'utilise un tableau de taille variable.
Ce bout de code pourra peut etre util. C'est en fait un tableau dynamique que j'ai codé sous lazarus. Voila ce que ça donne apres adaptation :
Il faudra changer TCase par le type desiré.Code:
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 unit utarraylist; {** ** Arraylist est un tableau d'objet TCase dynamique **} interface type tpointe=^pointe; pointe= record ca : TCase; suivant : tpointe; end; type TArrayList = object private tete, queue : ^pointe; taille : byte; public constructor init(); procedure add(ca: TCase); procedure addList(liste : TArraylist); function get(index : byte) : TCase; function getSize() : byte; destructor destroyed(); end; implementation {** ** construit la classe et initialise les propietes de la classe **} constructor TArrayList.init(); begin taille :=$0; tete:=nil; queue:=nil; end; {** ** ajoute des element en fin de la liste ** @require getSize()<255 **} procedure TArraylist.add(ca : Tcase); var p :tpointe; begin if (tete=nil) then begin new(tete); new(queue); tete^.ca:=ca; queue:=tete; tete^.suivant:=nil; taille:=$1; end else begin new(p); p^.ca:=ca; p^.suivant:=nil; queue^.suivant:=p; queue:=p; inc(taille); end; end; {** ** donne la taille de la liste ** @return la taille de la liste ** @ensure 0<=getSize()<=255 **} function TArrayList.getSize() : byte; begin getSize:=taille; end; {** ** retourne un element de la liste ** @param index la position de l'element dans la liste ** @return retourne l'element case correspondant a cette position ** @require 1<=index<=getSize() **} function TArraylist.get(index : byte) : TCase; var i : integer; p : tpointe; begin if index=$1 then begin get:=tete^.ca; exit; end; if index=$2 then begin get:=tete^.suivant^.ca; exit; end; if(index<$1) or (index>taille) then i:=taille; p:=tete; for i:=$1 to pred(index) do begin p:= p^.suivant; end; get:=p^.ca; end; {** ** ajoute les elements d'une liste donnee a la suite des elements de la courante ** @param liste la liste contenant les elements a ajoutes **} procedure TArrayList.addList(liste : TArraylist); var i : integer; begin for i:=$1 to liste.taille do add(liste.get(i)); end; {** ** libere les ressouces allouees dans la classe **} destructor TArrayList.destroyed(); var p : tpointe; begin while(tete<>nil) do begin p:=tete; tete:=tete^.suivant; dispose(p); end; end; end.
Bonjour darrylsite
c'est exactement ça ,Citation:
l'on essaie d'utilise un tableau de taille variable.
je vais essayer d'adapter ce code en TP7 . . . !
Tcase serait String
merci
Hoe,
Oui, mais la seule autorité pour la langue française étant l'Académie, il faut aller voir chez eux, et pas sur des blogs, qui participent très largement à l'appauvrissement culturel.
http://www.academie-francaise.fr/lan....html#au_temps
:)
Oui, sauf que dans ce cas (comme dans d'autres) l'Académie pèche encore par excès d'orgueil car l'origine de cette expression n'est absolument pas certaine tous les spécialistes de linguistique diachronique (historique si on préfère) vous le diront. Donc entre "au temps" et "autant" rien ne permet de trancher historiquement. Reste que l'Académie préconise "au temps" donc c'est cette forme qui doit être employée dans "le bon usage".
A noter que l'Académie avait aussi proposé l'absurdissime "mèl" pour e.mail au lieu du canadien et plus intelligent "courriel". Après quelques années nous en sommes au point suivant : un message électronique (un e.mail donc) doit se dire "courriel" et une messagerie électronique se dit"mèl". Pourquoi ne pas purement et simplement supprimer "mèl" qui ne sert à rien ? Parce que ce sont les "immortels" (mais souvent grabataires) qui ont essayé de l'imposer...
le problème c'est que l'informatique est un domaine technique.
et comme tout domaine technique/scientifique, nous utilisont les termes d'origine.
pour beaucoup, courriel, mél, gratuiciel, partagiciel, sont des termes absurdes et dénué de leurs nuance, substance, par rapport aux termes originaux email, freeware.
les termes comme shareware ou freeware ont un tout autre sens et une portée plus grande que les francissismes académique.
Share n'est pas seulement la notion de partage, mais de libre diffusion/copie et aussi on y comprend le sens de démonstration/bridage.
un shareware n'est pas seulement une version Demo (demonstration), Trial (Testez moi), mais bien l'ensemble de ces sens.
à l'identique, FreeWare ne posséde pas qu'une notion de gratuité, il vas au dela en affichant sa liberté, sa gratuité, son libre usage mais pas seulement.
le francissisme correcte d'email serait lettre-électronique. mais email à aussi un sens d'adresse électronique. et c'est la ou la compréhension de l'academie montre ses limites.
il serait plus correct et logique de préciser la nuance en utilisant lettre-électroniqe (ou eLettre) quand il s'agit d'un message eMail et adresse-électronique (ou eAdresse) quand il s'agit d'une adresse eMail.
mais à l'usage s'avère fastidieux.
nous utilisont tout les jours des mots latins, grecs, celtique, viking, allemand et pourtant on les consdères comme aquit de la langue française.
ne dit on pas Taxi ? Vasistas ? Manager ? Leader ? Hacker (dont la définition dans le dico est erroné!) etc. (<- encore un autre)
pourquoi ne pourrait on utiliser eMail, WebMail, Web, FreeWare, ShareWare, SoftWare, HardWare, SpyWare ?
c'est comme ça qu'une langue évolue.
( On s'éloigne du sujet originel mais comme ça c'est ma spécialité professionnelle, ça m'intéresse. )
Ceci n'est pas le vrai problème. 80 % des mots d'une langue sont reliés à un domaine "technique" (la cuisine est un domaine technique etc., etc.)
Tu fais allusion à ce qu'on appelle en linguistique "l'extension" d'un terme, i.e l'ensemble du domaine de sa signification (ou l'ensemble ds significations qui lui appartiennent). Les mots anglais "Share" (partager) et "ware" (quincaillerie, matériel) ne possèdent pas cette extension au départ, ils l'ont acquise par le contexte. Le même phénomène peut se produire pour des mots en français, sans aucun problème.
"mail" vient du mot français "malle-poste", nous avons gardé le 2ème mot (poste) et les anglo-saxons ont conservé le premier ("malle" transformé en "mail". d'ailleurs au XIX° siècle, "mail" signifiait encore également une grosse valise en anglais). Donc "courriel" est tout à fait exact. On peut l'utiliser à la fois pour le message et pour l'adresse (comme le font les anglo-saxons d'ailleurs), ce qui est d'ailleurs passé dans l'usage. Le problème est donc que l'Académie est trop théorique et ne regarde pas ce qui se passe dans la langue. D'ailleurs il ya très peu de véritables linguistes dans cette institution.
Certes.
Hmmm ... le problème n'est pas l'utilisation de mots empruntés à une uatre langue mais plutôt le double fait qu'ils ne sont empruntés qu'à une seule (l'anglais) ce qui appauvrit plutôt que cela enrichit et, surtout, que dans certains domaines (notamment la technologie, le commerce, i.e des domaines qui envahissent le quotidien) la proportion de mots anglais est 4 à 5 fois plus importante que dans la langue française en général, cela a tendace à provoquer une fracture dans la langue standard, entre ceux qui comprennent l'anglais et ceux qui ne le comprennent pas. C'est essentiellement une question de proportion.