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.