Procédure avec paramètre sans type

Version imprimable

21/03/2020, 14h13
ChPr

Procédure avec paramètre sans type

Bonjour à toutes et à tous,

Je cherche à faire une procédure unique d'enregistrement de différents types de records.

Cela veut dire que cette procédure doit accepter un paramètre "sans type" précis.

Il me semblais avoir vu cela, mais je ne trouve rien à ce sujet. J'ai peut-être rêvé.

Au cas où cela ne serait par un rêve, comment fait-on ?

Cordialement.

Pierre.
21/03/2020, 15h13
tourlourou

Bonjour,

N'est-ce pas une syntaxe type procedure Test(const Param); ?

Le passage en var doit également être possible.

Citation:

Envoyé par tourlourou

Bonjour,

N'est-ce pas une syntaxe type procedure Test(const Param); ?

Le passage en var doit également être possible.

Oui, merci, c'est effectivement ça. Je ne la retrouvais pas ça j'omettais le mot 'const' ou 'var'.

Pour autant, je n'ai pas l'impression que cela va m'aider à résoudre mon problème.

La procédure que je veux "généraliser est :
Code:

1 2 3 4 5 6 7 8 9 10 11 procedure Enregistrer; var i: Integer; FchDonnees: file of TDonnees_A; // Je veux pouvoir remplacer TDonnees_A par TDonnees_B ... begin AssignFile(FchDonnees, 'Monfichier.txt'); ReWrite(FchDonnees); for i:= 0 to High(MesDonnees) do Write(FchDonnees, MesDonnees[i]); CloseFile(FchDonnees); end;
J'ai déjà fait quelques essais, mais sans succès. Il faudrait que je puisse passer en paramètre non pas des variables, mais des types !

Cordialement.

Pierre.

C'est ce qui s'appelle un paramètre non typé.

Citation:

Envoyé par ChPr

Pour autant, je n'ai pas l'impression que cela va m'aider à résoudre mon problème.

Ça va dépendre de la façon dont le tableau est déclaré.
Si c'est un tableau de données numériques et de chaînes de taille fixe, pas de problème puisque les données sont contiguës.
Mais si le tableau contient des chaînes de taille variable ça ne fonctionnera pas puisque dans les faits ce sont des pointeurs.

Citation:

Envoyé par ChPr

La procédure que je veux "généraliser est :

La première remarque (par rapport au code de tourlourou) est qu'un paramètre non typé, eh bien on ne connaît pas sa taille ! Il faut donc au minimum un paramètre supplémentaire pour la spécifier.
Dans le cas d'AssignFile/Rewrite, il en faudrait même deux afin de limiter la taille du fichier. Un étant le nombre d'éléments et l'autre la taille de l'élément (si la taille est omise, Rewrite la considère de 128 octets).

La procédure serait par conséquent :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 procedure Enregistrer(const aBuffer; aItemSize, aCount: integer); var F :File; // Fichier non typé begin AssignFile(F, 'Monfichier.dat'); Rewrite(F, aItemSize); // En spécifiant la taille d'un élément, sinon 128 octets. BlockWrite(F, aBuffer, aCount); // Ce serait une erreur d'écrire seulement ici aCount*aItemSize puisque // la taille du fichier serait à l'arrivée de aCount*aItemSize*128 octets. CloseFile(F); end; // Appel Enregistrer(MonTableau[0], SizeOf(TUnElement), Length(MonTableau));
Une autre approche est bien sûr par stream :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 procedure Enregistrer(const aBuffer; aSize: integer); begin with TFileStream.Create('Monfichier.dat', fmCreate) do try WriteBuffer(aBuffer, aSize); finally Free; end; end; // Appel légèrement différent puisqu'on peut y passer la taille totale du tableau Enregistrer(MonTableau[0], Length(MonTableau) *SizeOf(TUnElement));
A la lecture, il y aura une étape supplémentaire qui consistera à déterminer le nombre d'éléments dans le fichier (Taille_du_fichier div SizeOf(TUnElement)) afin d'allouer le tableau avant l'appel de la fonction "Charger".

Citation:

Envoyé par Andnotor

... Ça va dépendre de la façon dont le tableau est déclaré. ...

Mes différents tableaux sont composés de données de type TDonnees_A, TDonnees_B ... Par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 TDonnees_A = record aa: String[128]; bb: String[64]; cc: Extended; dd: Integer; end; TDonnees_B = record aa: String[128]; bb: String[128]; cc: Extended; dd: Extended; ee: Integer; ff: Integer; end;
Avec la même procédure, il faut que j'enregistre par exemple un tableau de 10 données de type TDonnees_A ou bien 20 données de type TDonnees_B.

Est-ce que dans ce cas cela pourrait fonctionner ?

Cordialement.

Pierre.

22/03/2020, 23h12
Andnotor
C'est le but ;)
Code:

1 2 Enregistrer(MonTableau[0], SizeOf(TDonnees_A), Length(MonTableau)); Enregistrer(MonTableau[0], SizeOf(TDonnees_B), Length(MonTableau));
Après, si tu comptes être compatible Windows/Linux, il faut obligatoirement remplacer ce type Extended par autre chose, double par exemple. La taille d'un Extended étant dépendante de la plateforme.

Citation:
Envoyé par Andnotor
...
Code:

1 2 Enregistrer(MonTableau[0], SizeOf(TDonnees_A), Length(MonTableau)); Enregistrer(MonTableau[0], SizeOf(TDonnees_B), Length(MonTableau));
Après, si tu comptes être compatible Windows/Linux, il faut obligatoirement remplacer ce type Extended par autre chose, double par exemple. La taille d'un Extended étant dépendante de la plateforme.
J'ai déjà systématiquement remplacé tous mes Extended par des Double.

NOTA, j'avais pris cette habitude d'utiliser les Extended dans un logiciel de simulation où il y avait beaucoup de calculs cumulatifs afin de minimiser la propagation d'erreurs. Je l'utilise maintenant, sans faire attention, à toutes les sauces. Va falloir que ça change.

J'ai installé les procédures comme tu me l'a dit et, ça fonctionne très bien à l'enregistrement. Mais à la lecture, ça plante avec une message d'erreur 998 ! Pas trouvé ce que c'est. Voici les deux procédures que j'ai écrites :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 procedure TFntrCotisations.Charger(var aBuffer; aItemSize: Integer); var F: File; // Fichier non typé begin AssignFile(F, DirData+Sep+'MesCotisations.txt'); ReSet(F, aItemSize); while not EOF(F) do BlockRead(F, aBuffer, 1); // plante dès la première lecture avec erreur 998 CloseFile(F); end; procedure TFntrCotisations.Enregistrer(const aBuffer; aItemSize, aCount: Integer); var F: File; // Fichier non typé begin AssignFile(F, DirData+Sep+'MesCotisations.txt'); Rewrite(F, aItemSize); BlockWrite(F, aBuffer, aCount); CloseFile(F); end;
Je ne comprend pas d'où vient cette erreur.

Par ailleurs comment fait-on pour retrouver la taille d'un fichier assigné à F afin de tout lire d'un coup?

Cordialement.

Pierre.

Comme je te l'ai dit, tu dois passer par une étape supplémentaire pour déterminer le nombre d'enregistrements et allouer le tableau.

Un paramètre non typé n'est pas un pointeur mais une valeur. On ne peut pas passer nil à la fonction pour éventuellement l'allouer dans la même procédure que le chargement. On doit le faire avant.
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 function GetRecordCount(aItemSize: Integer) :integer; var F: File; begin AssignFile(F, 'MesCotisations.txt'); Reset(F, aItemSize); Result := FileSize(F); CloseFile(F); end; procedure Charger(var aBuffer; aItemSize, aCount: Integer); var F: File; begin AssignFile(F, 'MesCotisations.txt'); Reset(F, aItemSize); BlockRead(F, aBuffer, aCount); CloseFile(F); end; procedure TForm1.Button1Click(Sender: TObject); var Count :integer; begin Count := GetRecordCount(SizeOf(TDonnee_A)); SetLength(MonTableau, Count); // <-- allocation Charger(MonTableau[0], SizeOf(TDonnee_A), Count); end;

23/03/2020, 14h01
ChPr

Citation:

Envoyé par Andnotor

Comme je te l'ai dit, tu dois passer par une étape supplémentaire pour déterminer le nombre d'enregistrements et allouer le tableau. ...

Ok, j'ai compris, mis en œuvre : c'est OK.

Merci beaucoup.

Pierre.

Bon, le but était une petite explication sur les paramètres non typés.

Voici une autre approche qui serait tout aussi fonctionnelle et plus compact.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
procedure Enregistrer2(const aBuffer :TBytes; aItemSize :integer);
begin
  with TFileStream.Create('d:\Monfichier.dat', fmCreate) do
  try
    WriteBuffer(aBuffer, Length(aBuffer) *aItemSize);
  finally
    Free;
  end;
end;
 
procedure Charger2(var aBuffer :TBytes; aItemSize :integer);
begin
  with TFileStream.Create('d:\Monfichier.dat', fmOpenRead) do
  try
    SetLength(aBuffer, Size div aItemSize);
    ReadBuffer(aBuffer, Size);
  finally
    Free;
  end;
end;
 
Enregistrer2(TBytes(MonTableau), SizeOf(TDonnee_A));
Charger2(TBytes(MonTableau), SizeOf(TDonnee_A));

Citation:

Envoyé par Andnotor

Bon, le but était une petite explication sur les paramètres non typés.

Voici une autre approche qui serait tout aussi fonctionnelle et plus compact. ...

Voilà qui paraît encore plus simple. Mais j'ai un problème au chargement. J'ai quelque peu modifié tes procédure (ajout du nom de fichier) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 procedure Enregistrer2(const aBuffer :TBytes; aItemSize :integer; Fch: String); begin with TFileStream.Create(DirData+Sep+Fch, fmCreate) do try WriteBuffer(aBuffer, Length(aBuffer) *aItemSize); finally Free; end; end; procedure Charger2(var aBuffer :TBytes; aItemSize :integer; Fch: String); var n: Integer; begin with TFileStream.Create(DirData+Sep+Fch, fmOpenRead) do try n:= Size; // --> représente bien le nombres de bytes de mon tableau SetLength(aBuffer, Size div aItemSize); ReadBuffer(aBuffer, Size); finally Free; end; end;
L'enregistrement se passe bien : un fichier est créé avec la même dimension qu'avant bien que le structure interne soit différente.

Code:

Enregistrer2(TBytes(TauxCotisations), SizeOf(TCotisation), 'MesCotisations.txt');

Le chargement se passe bien, mais quand je veux exploiter le résultat, ça plante.
Code:

1 2 Charger2(TBytes(TauxCotisations), SizeOf(TCotisation), 'MesCotisations.txt'); n:= Length(TauxCotisations); // --> valeur incohérente
je me retrouve avec un n qui vaut 1 milliard et des brouettes ???

Il y a certainement encore quelque chose que je n'ai pas compris.

Cordialement.

Pierre.

Essaie ainsi :

Code:

1
2
3
4
5
6
7
8
9
10
procedure Charger2(var aBuffer :TBytes; aItemSize :integer; Fch: String);
begin
  with TFileStream.Create(DirData+Sep+Fch, fmOpenRead) do
  try
    SetLength(aBuffer, Size div aItemSize);
    ReadBuffer(aBuffer[0], Size);
  finally
    Free;
  end;
end;

Idem sur WriteBuffer.

Citation:
Envoyé par Andnotor
Essaie ainsi :
Code:

1 2 3 4 5 6 7 8 9 10 procedure Charger2(var aBuffer :TBytes; aItemSize :integer; Fch: String); begin with TFileStream.Create(DirData+Sep+Fch, fmOpenRead) do try SetLength(aBuffer, Size div aItemSize); ReadBuffer(aBuffer[0], Size); finally Free; end; end;
Idem sur WriteBuffer.
J'ai appliqué cette modification dans Enregistrer2 et Charger2.

L'enregistrement s'est bien passé. J'ai fermé l'application, puis :
J'ouvre l'application : le chargement se passe bien ; il y a bien le bon compte de record ; je les vois bien dans mes affichages sauf que dans un string du premier record chargé, la valeur passe de '"Taux 2019" à "Taux!2019". L'espace a été remplacé par un point d'exclamation.
Je ferme l'application, qui ne fait rien au sujet de ces fichiers et j'obtiens une erreur SIGSEGV
Je réouvre l'application, le chargement se passe bien, mais dès que l'application fait appel aux valeurs chargées, il se plante avec une erreur SIGSEGV
Le même scénario se répète quand je réouvre l'application.

Si ça peut aider, ça se passe là :
Code:

1 2 3 SYSTEM_$$_SYSGETMEM_FIXED$QWORD$$POINTER (155) ... 0000000100011D80 48C7401000000000 movq $0x0,0x0 (%rax)
Bref, il y a un truc qui ne tourne pas rond.

Cordialement.

Pierre

25/03/2020, 09h34
Andnotor

Citation:

Envoyé par ChPr

sauf que dans un string du premier record chargé, la valeur passe de '"Taux 2019" à "Taux!2019".

M'est avis que tu as une erreur ailleurs. Soit l'ensemble de la donnée est corrompue, soit il ne l'est pas. Un seul caractère est difficilement compréhensible.

Je n'ai rien relevé de particuliers (VA ou corruption) à travers mes différents essais, peu importe comment le fichier était sauvé et rechargé (ex. AssignFile en écriture et TFileStream en lecture).

Citation:

Envoyé par Andnotor

M'est avis que tu as une erreur ailleurs. Soit l'ensemble de la donnée est corrompue, soit il ne l'est pas. Un seul caractère est difficilement compréhensible. ...

C'est possible, mais je ne la vois pas.

Voilà la structure que je souhaite enregistrer/charger :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 TCotisation = record {Paramètres des cotisations} NoCotis: Integer; Nom: String[128]; {Nom donné à cette grille de taux de cotisations} PlafondSS: Double; NbHparMois: Double;{Nombre d'heures par mois pour une semaine de xx heures} SMIC: Double; {SMIC horaire brut} CSG_ND, CSG_D: Double; CRDS_ND: Double; AssMalade_S, AssMalade_P: Double; AssAge_DP_S, AssAge_DP_P: Double; AssAge_P_S, AssAge_P_P: Double; AssVeuve_S, AssVeuve_P: Double; AccTravail_S, AccTravail_P: Double; AllFamille_S, AllFamille_P: Double; AidLogement_DP_S, AidLogement_DP_P: Double; AidLogement_P_S, AidLogement_P_P: Double; AssChomageA_S, AssChomageA_P: Double; AssChomageB_S, AssChomageB_P: Double; AssChomageAGS_S, AssChomageAGS_P: Double; RetraiteC1_S, RetraiteC1_P: Double; RetraiteC2_S, RetraiteC2_P: Double; end;
Ce qu'est "TauxCotisations" :

Code:

TauxCotisations: array of TCotisation;

Les procédures d'enregistrement et de chargement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 procedure Enregistrer2(const aBuffer :TBytes; aItemSize :integer; Fch: String); begin with TFileStream.Create(DirData+Sep+Fch, fmCreate) do try WriteBuffer(aBuffer[0], Length(aBuffer) *aItemSize); finally Free; end; end; procedure Charger2(var aBuffer :TBytes; aItemSize :integer; Fch: String); begin with TFileStream.Create(DirData+Sep+Fch, fmOpenRead) do try SetLength(aBuffer, Size div aItemSize); ReadBuffer(aBuffer[0], Size); finally Free; end; end;
et les appels de ces procédures :

Code:

Enregistrer2(TBytes(TauxCotisations), SizeOf(TCotisation), 'MesCotisations.txt');

Code:

Charger2(TBytes(TauxCotisations), SizeOf(TCotisation), 'MesCotisations.txt');

Si l'enregistrement et le chargement se passent bien c'est tout de suite après le chargement que le problème survient, dès que je fais référence à ce qui vient d'être chargé.

Je ne vois pas où pourrait être le bug.

Cordialement.

Pierre