THE PROBLEM
I have two classes that have references to each other and
I want to save them in separate files. The files look like
this,

unit unitA;
uses
        unitB;
type
        TClassA=class
                b:TClassB;
        end;
implementaion
etc...

unit unitB;
uses
        unitA;
type
        TClassB=class
                a:TClassA;
        end;

and of course I got a circular unit reference error, is there  
a way to go around this.

Regards

Ulf Mansson
--

: >THE PROBLEM
: >I have two classes that have references to each other and
: >I want to save them in separate files. The files look like
: >this,

: >unit unitA;
  { Get rid of this here
: >uses
: >        unitB;
  }
: >type
: >        TClassA=class
: >                b:TClassB;
: >        end;
: >implementaion

   { put it here }
  uses UNITB;

In other words just move the uses clause to the implementation section.

You can't have these in separate units, but there's nothing to stop you from
putting them in different files that are included in the same unit.  I'd
suggest putting the interface section in one file, and the two implementations
in separate include files.

  There is a standard trick for this kind of situation: Say unit B is logically
  the one that should depend on A. Then you make a new class TSuperB which is
  included in unit A. It should look like this:

  TSuperB=class
    <The harmless attributes needed in this unit>

    <Methods needed in this unit, declared as virtual with empty bodies, to be
     filled out in unit B.>
  END;

  And then you make TClassB a subclass of TSuperB. This won't always work, but
  it solves most problems of this kind. The key is the virtual methods.

  --Lars M.
_______________________________________________________________________________

  -- Lars M. Garshol, Institute of Informatics, Oslo University

unit unitA;
uses
        unitB;
type
        TClassA=class
                b:TClassB;
        end;
implementaion
etc...

unit unitB;
type
        TClassB=class
                a:TClassA;

implementation
uses
        unitA;
etc...

Good Luck,

Don Huff
dh...@sky.net

: THE PROBLEM
: I have two classes that have references to each other and
: I want to save them in separate files. The files look like
: this,

: unit unitA;
: uses
:       unitB;
: type
:       TClassA=class
:               b:TClassB;
:       end;
: implementaion
: etc...

: unit unitB;
: uses
:       unitA;
: type
:       TClassB=class
:               a:TClassA;
:       end;

: and of course I got a circular unit reference error, is there  
: a way to go around this.

: Regards

: Ulf Mansson
: --

unitA

type
  PClassA=^TClassA (a pointer to types of TClassA)
  TClassA=class
         b : pointer (general pointer, because TClassB is not known yet)
  end;

implementation

uses
  UnitB
  etc....

unitB

uses
  UnitA (No circular references...)

type
  PClassB=^TClassB (a pointer to type of TClassB)
  TClassB=class
        a : PClassA (or TClassA, I prefer the first for consistancy)
  end;

implementation
etc...

To acces the b field in TClassA records as an instance of type TClassB
you'll have to do the following:

  PClassB(b)^ (this is called typecasting)

I hope this solves your problem.

Place the first use clause in the interface part of Unit A

I still think the best solution is to put both classes in the same unit,
possibly in separate include files.  These two classes must be intimately
related if they use each other so closely, so it makes sense for them to be
logically grouped together.  

A valid reason to employ one of these kludges to get them into separate units
would be if the implementations involved so much code that it wouldn't all fit
into one unit.  In that case, it would probably make sense to have multiple
types in a hierarchy anyways; I don't think I've ever needed 64K of code to
implement just two object types.

If they have references to each other, their definitions should be in
one file. Just create a unitC which contains the typedefs in the interface
section. Then you can use unitC in unitA & unitB.
  Circular references are a sign of bad decomposition. Please look very
careful at your interface sections.

/Ulf Mansson
--