Discussion :

[WebPac]

Bonjour tout le monde,

voici ce que je cherche à faire :
avoir 2 classes dans 2 unités différentes et chacune des classes ayant une référence du type de l'autre classe.

Exemple :

Code :

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

1
2
3
4
5
type
  TMyObject = class( TComponent )
  private
    FMyObject2 : TMyObject2;
  end;

Et faire de même dans la déclaration de TMyObject2.
Bien entendu, on ne peut pas mettre dans les uses interface l'unité de l'autre classe, sinon on aurait des uses circulaires.

Je me suis dit, qu'une solution serait de mettre TMyObject2 dans le uses de MyObject puis faire une prédéclaration de TMyObject dans l'unité de TMyObject2.

Exemple :

Code :

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

1
2
3
4
5
6
type
  TMyObject = classs;
  TMyObject2 = class( TComponent )
  private
    FMyObject : TMyObject;
  end;

Mais dans ce cas, j'ai le message d'erreur :

Le type TMyObject n'est pas encore complètement défini.

J'ai l'impression que je n'ai le droit de faire une prédéclaration que dans l'unité qui déclare la classe.

Une solution serait de mettre les 2 classes dans la même unité, mais comme chaque classe est énorme (dépasse les milliers de ligne), je préfère les garder dans des unités séparées.

Pour l'instant, j'ai un objet qui est l'owner de l'autre, donc je passe par l'owner et je transtype, c'est pas très propre mais ça marche tant que je n'ai pas d'autre solution.

Est-ce que faire une prédéclaration est une bonne solution et il y a une astuce que j'ai zappé ou dois-je continuer à utiliser les owner car il n'y a pas d'autre solution ?

[anapurna]

salut

ce que tu veut faire ne peut pas ce faire directement
il te faut passer par un ancetre de ta classe c'est les fameux probleme de reference circulaire

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
Unit UMyClaseBase 
 TmyClassBase = TComponent 
 end;
(****************************)
unit UMyObject
uses UMyClaseBase;
 type
  TMyObject = class( TComponent )
  private
    FMyObject2 : TmyClassBase;
  end;
(****************************)
unit MyObject2
uses UMyClaseBase,UMyObject;
type
  TMyObject2 = class(TmyClassBase)
  private
    FMyObject : TMyObject;
  end;

@+ Phil

[WebPac]

Salut Phil et merci de proposer une solution, mais en utilisant une classe mère, on est obligé de faire un transtypage pour pouvoir travailler avec, ce qui ne résoud pas vraiment mon problème, c'est comme en utilisant l'owner.

[tourlourou]

ne serait-ce point une solution que d'utiliser des interfaces ?

[Graffito]

Bonjour,

Je ne sais pas si ça répond à la question, mais pour faire des références circulaires dans les clauses Uses de 2 units Unit1 et Unit2 , il suffit de mettre dans "uses Unit1" dans la partie implémentation de Unit2.

[WebPac]

Salut Graffito mais avec ta méthode ça ne marche pas, je le fais déjà mais on ne peut pas utiliser chacune des classes dans l'autre dans la partie declaration, on est obligé d'en avoir une utilisée qu'à partir d'implementation et ce n'est pas ce que je désire faire.

Salut tourlourou, j'ai essayé de faire une sorte d'utilisation d'interfaces sans utiliser des interfaces et j'ai eu ces messages d'erreur :

Le type TMyObject n'est pas encore complètement défini.

Par contre, utiliser des interfaces, ça n'oblige pas d'instancier des méthodes utiles pour les interfaces comme le compteur de références et d'autres choses galères à utiliser ?

As-tu un exemple simple à montrer ?

[sjrd]

@Graffito : oui si une unité n'utilise le type de l'autre que dans sa partie implémentation Or là il s'agit bien d'avoir les références dans la partie interface des deux côtés (enfin c'est ce que j'ai cru comprendre).

@WebPac : la solution est évidemment, comme tu l'as dit toi-même, de placer les deux classes dans la même unité. Même si elles font des milliers de lignes, c'est comme ça.

Si l'on réfléchit un peu au sens du mot unité : il s'agit bien de construire une entité unique. À l'intérieur de cette entité, tout ou presque est possible : aussi bien faire des références circulaires entre classes qu'accéder aux variables privées d'autres classes. Mais dès qu'on sort de l'unité, celle-ci apparaît comme une enveloppe à laquelle on ne touche pas, si ce n'est en lecture à sa section interface.

Il est donc par nature et par essence impossible de faire ce que tu veux.

[WebPac]

Merci sjrd pour ces précisions, donc ça veut dire qu'avec des interfaces ça ne marchera pas non plus, c'est dommage.

Je vais devoir garder mes ( Owner as TMyObject ).... un peu partout dans le code, je trouve les transtypages pas très propres, mais bon tant pis, tant que ça marche.

[tourlourou]

je ne suis pas spécialiste des interfaces (ni du reste, d'ailleurs!) ; mais je voyais les choses comme ça :

unit 3 qui déclare 2 types d'interfaces (1 par type d'objet) avec les méthodes nécessaires

dans chaque unité, tu fais hériter l'objet de l'interface adéquate, tu implémentes les méthodes

comme chaque unité utilise cette unit 3, elle connaît l'interface sur l'autre objet => récupération des champs nécessaires, sans en connaître rien d'autre, ce qui est conforme au fait d'avoir des unités séparées, et des interfaces qui masquent les détails

reste à prouver que ça marche autrement qu'en théorie...

[WebPac]

Dès que j'ai le temps de tester, j'essaierai la méthode avec les interfaces.

@ sjrd : si le CTRL + MAJ + C marchait parfaitement à chaque fois et ne rajoutait pas parfois les nouvelles méthodes en toute fin d'unité (et donc mélange les méthodes des différentes classes), peut-être que j'essaierai de mettre les classes dans les même unités, mais tant qu'il ne marche pas bien, je ne vais pas le faire.

[sjrd]

Je vais devoir garder mes ( Owner as TMyObject ).... un peu partout dans le code, je trouve les transtypages pas très propres, mais bon tant pis, tant que ça marche.

Utilise plutôt TMyObject(Owner) C'est beaucoup plus court à écrire et à exécuter

[WebPac]

Utilise plutôt TMyObject(Owner) C'est beaucoup plus court à écrire et à exécuter

Voui, on gagner 2 lettre AS
Mais pour les pointilleux, c'est moins rigoureux car ça ne teste pas le transtypage incorrect.

[anapurna]

salut


effectivement le transtypage est obligatoire
mais car il y a toujour un mais tu doit le definir qu'a deux endroit
dans le "setMonObjet" et le "getmonObjet"
apres il te suffit de faire appele a c'est deux methode pour acceder a ton objet interne

@+ Phil

[WebPac]

Salut anapurna,

mais si on ne peut pas déclarer de TMyObject dans la déclaration de TMyObject2, on ne peut pas non plus déclarer SetMonObjet et GetMonObjet qui prennet TMYObject en paramètre et en résultat de méthode.

[e-ric]

Est-il vraiment impératif de répartir tes classes dans 2 unités séparées?

cdlt

e-ric

[WebPac]

Etant donné que chaque classe dépasse les plusieurs milliers de ligne et que le CTRL + MAJ + C rajoute régulièrement les nouvelles méthodes en fin d'unité, je répondrai "oui".

[anapurna]

salut

je reprend mon code

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
Unit UMyClaseBase 
 TmyClassBase = TComponent 
 end;
(****************************)
unit UMyObject
uses UMyClaseBase;
implementation
 type
  TMyObject = class( TComponent )
  private
    Function getmyClass : TmyClassBase; 
    Function stMyClass(value : TmyClassBase);
    FMyObject2 : TmyClassBase;
  end;
...
interface
uses  MyObject2;
 
Function TMyObject.getmyClass : TmyClassBase; 
begin
  if FMyObject2 is TMyObject2  Then
    Result := FMyObject2 as TMyObject2 
  else 
    Result := nil ;
end;
 
Function TMyObject.setMyClass(value : TmyClassBase);
begin
   if value is TMyObject2  Then
     FMyObject2 :=  value as TMyObject2   
   else raise Exception.Create('Erreur la classe n''est pas valide') ;
end;
 
end;
 
(****************************)
unit MyObject2
uses UMyClaseBase,UMyObject;
type
  TMyObject2 = class(TmyClassBase)
  private
    FMyObject : TMyObject;
  end;

essai ceci est dit moi si cela fonctionne
pas tester

@+ phil

[WebPac]

Salut anapurna, ta solution ne marche pas car tu mets :

Code :

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

1
2
3
    Function getmyClass : TmyClassBase; 
    Function stMyClass(value : TmyClassBase);
    FMyObject2 : TmyClassBase;

Hors il faudrait que le type soit TMyObject2 ou sinon, dans cet exemple, à chaque fois que j'utiliser GetMyClass, je dois trantyper la valeur de retour en TMyObject2.

[anapurna]

salut

a quoi te sert l'autoreferencement exactement ?

@+ Phil

[sjrd]

Mais pour les pointilleux, c'est moins rigoureux car ça ne teste pas le transtypage incorrect.

Je suis du genre pointilleux, et je ne considère pas le transtypage comme irrigoureux. Il s'agit là de deux utilisation différentes : as quand il serait possible que l'objet ne soit pas de la bonne classe ; transtypage quand ce serait un bug du programme.
Quid du transtypage et de l'opérateur as ?