quelques interrogations supplémentaires...
Merci à tous pour votre réactivité et vos pistes de travail.
En fait, au départ, je souhaite "saucissonner" mon programme en cours, car les lignes s'accumulant, il est très difficile de s'y retrouver vraiment.
Je désire donc agir de la manière suivante :
- un corps "principal", avec tout le déroulement et les appels aux procédures.
- des unités .pas pour rédiger, relire et modifier aisément ces procédures.
En fait, j'ai rapidement vu qu'il est difficile d'appeler des "morceaux de prgs" sous forme de fiches, avec des variables communes, sans avoir le problème de non déclaration ou appel circulaire.
j'ai fait un petit essai qui à l'air de fonctionner :
le prg principal fait apparaitre des clauses "uses" de chaque fiche dans la partie "implémentation".
La variable "message", déclarée dans la partie "interface" peut être utilisée par les différentes fiches.
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
| unit Unit11;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs;
type
TForm11 = class(TForm)
procedure FormActivate(Sender: TObject);
private
{ Déclarations privées }
public
{ Déclarations publiques }
end;
var
Form11: TForm11;
message : string;
implementation
uses unit12, unit13;
{$R *.dfm}
procedure TForm11.FormActivate(Sender: TObject);
begin
message := (' je suis dans l''unité 11');
showmessage (message);
phrase12 ;
showmessage (message);
phrase13 ;
showmessage (message);
end;
end. |
Chaque fiche fait apparaitre le prg principal dans la partie "implémentation" et indique l'en-tête de la procédure traitée dans la partie "interface" et utilise la variable partagée "message".
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| unit Unit12;
interface
procedure phrase12 () ;
implementation
uses unit11;
procedure phrase12 ();
begin
message := (' je suis entré dans l''unité 12');
end;
end. |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| unit Unit13;
interface
procedure phrase13 ();
implementation
uses unit11;
procedure phrase13 ();
begin
message := (' je suis entré dans l''unité 13');
end;
end. |
Cela fonctionne pour cet exemple simple, mais ce principe peut-il être appliqué pour un programme des plusieurs centaines de lignes?
Le principe de "saucissonnage" est -il correct? adapté? ou dois-je faire autrement pour être efficient? Merci à tous!
Eviter une unité fourre-tout
merci à tous pour vos contributions!
Pour éviter le coté "fourre-tout" d'une unité partagée, et permettre une réutilisation plus facile des fiches, le principe ci-dessous est-il correct?
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
| unit Unit11;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, calcul;
type
TForm11 = class(TForm)
private
{ Déclarations privées }
public
{ Déclarations publiques }
end;
var
Form11: TForm11;
nb1, nb2 : integer;
implementation
{$R *.dfm}
begin
nb1 := 10;
nb2 := 5;
produit (nb1,nb2);
showmessage ('le resultat est : ' + resultat.ToString);
end. |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| unit calcul;
interface
var resultat : integer;
procedure produit (i,j : integer) ;
implementation
procedure produit ;
begin
resultat := i*j;
end;
end. |
L'unité secondaire "calcul", possède sa procédure et sa variable déclarée, accessibles à tous, car dans la partie interface.
Le projet principal ajoute "calcul" dans ses "uses" et ainsi, peut appeler la procédure "produit" et accéder à la variable "résultat".
Le passage des paramètres se fait par l'appel de la procédure, qui les traite en variables locales "i" et "j", mettant à disposition "resultat" pour toutes les fiches faisant apparaitre le "uses calcul".
Cela est-il correct? Ce principe est-il applicable pour plusieurs procédures plus compliquées?
