[OOP]? Instelling moet functie bepalen

[Verwijderd]

Ik ben bezig met een applicatie die een apart device uit moet kunnen lezen. Voor dit uitlezen heb ik voorlopig twee manieren geprogrammeerd: Via de seriele of de paralelle poort.

In de applicatie kan ik bij de instellingen aangeven welke methode gebruikt moet worden.

Als de functie uitlezen wordt aangeroepen check ik eerst met een simpel if-statement welke instelling er is gekozen. Afhankelijk hiervan spring ik naar LeesSerieel() of LeesParallel(). Nou denk ik dat dit beter moet kunnen op een OOP manier, zodat afhankelijk van de instelling direct de juiste manier wordt gekozen. Daar kom ik echter niet echt uit. Heeft iemand hiervoor een goeie suggestie? Of is er geen andere manier?

Straks wil ik nl. ook de USB versie gaan maken, en dit zorgt dan voor redelijk veel werk om dit toe te voegen. Het moet dus haast wel anders/beter kunnen.

BTW: Nu is alles in Delphi ingeklopt, maar ik denk er hard over om naar C++ over te stappen.

Thanx.

edit:

Programmeertaal vergeten...

[Onno]

Uhm.. gewoon iets als dit?

code:

type
  TDevice = class
    procedure Lees(); virtual;
    ...
  end;

  TSerialDevice = class(TDevice)
    procedure Lees(); override;
    ...
  end;

  TParallelDevice = class(TDevice)
    procedure Lees(); override;
    ...
  end;

var
  device:TDevice;

procedure TDevice.Lees();
begin
  ...
end;

procedure TSerialDevice.Lees();
begin
  ...
end;

procedure TParallelDevice.Lees();
begin
  ...
end;

begin
  if (...)
    device = TSerialDevice.Create()
  else
    device = TParallelDevice.Create();
  device.Lees();

end.

[mbravenboer]

Je kan inderdaad gewoon een interface definieren en deze op verschillende manieren implementeren. Je kan dit daarna heel mooi combineren met een Factory design pattern. Deze factory maakt dan instanties van je concrete implementatie.

In omgevingen met dynamic-class-loading zou de instelling heel gemakkelijk kunnen verwerken zonder gevalsonderscheid door de concrete implementatie dynamisch aan te maken.

[Juicy]

Of op de C++ manier:

class CDevice {
virtual bool read(...);
}

clas CSerialDevice : public CDevice {
bool read(...);
}

class CParallelDevice : public CDevice {
bool read(...);
}

class CUsbDevice : public CDevice {
bool read(...);
}

[Verwijderd]

if (...)
device = TSerialDevice.Create()
else
device = TParallelDevice.Create();
device.Lees();

Maar als eerst de serieele variant is gekozen en daarna de parallele, dan heb ik dus twee keer de variabele naam 'device'. Of is het in delphi zo (net als in C++) dat na een functie de lokale variabelen automatisch worden opgeheven?

[Onno]

Op dinsdag 04 december 2001 20:21 schreef delighteddennis het volgende:
Maar als eerst de serieele variant is gekozen en daarna de parallele, dan heb ik dus twee keer de variabele naam 'device'.

In de code die jij quote wordt helemaal geen variabele gemaakt, dat gebeurt hier:

code:

var
  device:TDevice;

Dus uhm...

[Verwijderd]

ik zit inderdaad ernstig te slapen

[Korben]

Of je doet het zo: (in C++)

code:

class dev_reader()
{
  ...

  void (*read)();

  ...
};

void read_serial()
{
}

void read_parallel()
{
}

void read_usb()
{
}

void read_firewire() // ;)
{
}

int main()
{
  ...

  dev_reader *a_dev_reader;

  ...

  if (...)
  {
    a_dev_reader->read = read_serial;
  }
  else
  {
    a_dev_reader->read = read_parallel;
  }

  ... 

  a_dev_reader->read();

  ...
}

[Onno]

Dat is niet echt een OOP oplossing.

[Korben]

Op vrijdag 07 december 2001 11:17 schreef Onno het volgende:
Dat is niet echt een OOP oplossing.

Klopt, maar zo kun je als je wilt via een DLL nieuwe drivers gebruiken. Soft-coded dus.

[Onno]

Eh.. dat kan toch ook wel als je een class extend?