[kakarotv5]

Empezado por Neftali

Hay un caso en que a mi me ha salido bastante.
Imagina las clases de un Frame de persistencia. Cada clase en una Unit, para ser ordenado.
Las relaciones recíprocas entre dos tablas se convierten en referencias circulares entre units.

Por ejemplo:
Persona está relacionado con empresa (pertenece), pero empresa también está relacionado con persona (contacto).

Alguien que me entiende.

Vale, os pongo un ejemplo que se me acaba de ocurrir:

Imaginad un dispositivo que además de servir de entrada de datos sirve de salida también, este dispositivo está controlado por una unidad de control.

Tenemos el siguiente funcionamiento:

1) El dispositivo de entrada salida envía una entrada a la unidad de control y esta la almacena.
2) La unidad de control envía un dato al dispositivo de entrada salida y este genera un mensaje.

A mi se me ocurre esta implementación a priori:

Código Delphi [-]
unit uEntradaSalida;

interface

uses StdCtrls, uUnidadControl;

type
  cEntradaSalida = class
                           private
                            Entrada: string;
                            Salida: string;
                            UControl: cUnidadControl;
                           public
                            constructor Create(E: string; S: string; UC: cUnidadControl);
                            procedure EnviarDato;
                            procedure RecibirDato(E);
                           end;

implementation

{ cEntradaSalida }

constructor cEntradaSalida.Create(E: string; S: string; UC: cUnidadControl);
begin
 Entrada := E;
 Salida := S;
 UControl := UC;
end;

procedure cEntradaSalida.EnviarDato;
begin
 UControl.AlmacenarDato(Entrada);
end;

procedure cEntradaSalida.RecibirDato(Dato: string);
begin
 Salida := Dato;
 ShowMessage(Salida);
end;

end.

Código Delphi [-]
unit uUnidadControl;

interface

uses uEntradaSalida;

type
  cUnidadControl = class
                           private
                            Dato: string;
                            EntradaSalida: cEntradaSalida;
                           public
                            constructor Create(Dat: string; ES: cEntradaSalida);
                            procedure AlmacenarDato(Dat: string);
                            procedure EnviarDato;
                           end;

implementation

{ cUnidadControl }

constructor cUnidadControl.Create(Dat: string; ES: cEntradaSalida);
begin
 Dato := Dat;
 EntradaSalida := ES;
end;

procedure cUnidadControl.EnviarDato;
begin
 EntradaSalida.RecibirDato(Dato);
end;

procedure cUnidadControl.AlmacenarDato(Dat: string);
begin
 Dato := Dat;
end;

end.

Se que esto, según está planteado es imposible de que compile en Object Pascal.

Puede que el ejemplo os parezca enrevesado pero os aseguro que hay ejemplos no inventados por mi sino otros estudiados en la Ingeniería del Software que no son soportados por Object Pascal a no ser de que se introduzca más de una clase en una misma unidad (si os pica la curiosidad os diré cual es).

Una solución a esto es hacer tres clases:

uUnidadControl.pas
uEntrada.pas
uSalida.pas

Mi pregunta es si en otros lenguajes de programación como Java o C++ por ejemplo ocurre esto también.

Saludos.