[C++] functie in afgeleide klasse benaderen?

[cire]

Ik zit met het volgende probleem. (In C++)

Ik heb een klasse, zeg 'module'

Daarvan zijn er een paar subklasses, zeg 'submodule1', 'submodule2'.

Ik heb een verwijzing m naar 'module'. Waarbij ik zeker weet dat m een van beide submodules is.

Ik wil afhankelijk van welke submodule m is, een bepaalde functie aanroepen. Ik wil dus een 'if then' doen op het type submodule.

Hoe doe ik dat?

[Zoijar]

Zoek dynamic_cast<> is op, kan handig zijn. Maareh ... is niet het idee dat je dan een puur virtuele methode in module maakt, en die overload in de 2 submodules? Je probleem is precies de rede om inheritance te gebruiken.

[cire]

Bedankt, zoiets zocht ik inderdaad.

Je hebt gelijk met je opmerking over inheritance, maar 'module' kan ik zelf niet veranderen.
Bovendien is een probleempje dat de functie(s) die ik wil aanroepen niet per afgeleide klasse hetzelfde zijn. Ik bedoel, een totaal andere aanroep hebben.

[Gerco]

In java heb je daar de 'instanceof' operator voor. Bestaat er in C++ niet iets dergelijks?

[Zoijar]

dynamic_cast

[The End]

Je kan in de afgeleide class de functies overloaden... Dit is eigenlijk de bedoeling... Je zou ook in je prog dit kunnen doen:

if (IsKindOf(SubModule1))
{
SubModule1.blablabla()
}

[Verwijderd]

in java kan je toch gewoon

code:

Class Module
{
  void function_function()
  {
    //bla
  }
}

Class SubModule extends Module
{
  void module_function()
  {
    //bla - overloading function
  }
}

doen

En als Module dan een SubModule is dan wordt dus SubModule's module_function() aangeroepen en anders Module's module_function()...

Kan dat in C++ dan niet ook? Waarom dan al dat ge-instanceof en <bladiebla>

/me doet weinig C++, eigenlijk alleen C

[Zoijar]

http://docs.sun.com/htmlcoll/coll.32.8/iso-8859-1/CPPPG/Cast.html

Verklaard veel.

[cire]

En als Module dan een SubModule is dan wordt dus SubModule's module_function() aangeroepen en anders Module's module_function()...

Kan dat in C++ dan niet ook? Waarom dan al dat ge-instanceof en <bladiebla>

Zeker kan dit ook in C++. Maar daar gaat het helemaal niet om. Waar het hier om gaat is dat je afhankelijk van welke submodule je 'te pakken hebt', een andere functie wilt uitvoeren. En daarvoor moet je eerst weten welke submodule het is.

[.oisyn]

^{... kuch ...}

ik begin ze haast leuk te vinden, die huiswerk C++ topics, maakt de boel een stuk gezelliger

[mbravenboer]

OiSyN: die huiswerk C++ topics

Op zich opvallend dat er bijna geen Java huiswerk topics zijn. Hoe zou dat toch komen .

Om even terug te komen op de vraag: als je beide typen generiek wilt laten behandelen (poliemorfie noemen ze dat ), dan moet je gewoon in de gemeenschappelijke superklasse een virtuele methode opnemen. Deze implementeer je in alle varianten van het type.

Als je de objecten niet generiek kan behandelen is het dus ook niet generiek en moet je het ook niet generiek maken.

[whoami]

Polymorfisme is hier idd de oplossing, in code gaat het zo:

code:

class BaseClass
{
 private:
 public:
   virtual void functie_naam()
   {
    doe_iets();
   }
};

class SubClassA : public BaseClass
{
  public:
     void functie_naam()
     {
      doe_ietsanders();
     }
};

class SubClassB : public BaseClass
{
  public:
     void functie_naam()
     {
      doe_not_iets_anders();
     }
};

void main()
{
  BaseClass*   bc;

  bc = new SubClassA;
  bc->functie_naam();
  bc = new SubClassB;
  bc->functie_naam();
  delete bc;
}

[whoami]

Je kan ook uw virtuele functie in de base-class pure virtual maken, dwz dat ze in de Base class niets doet. (In Java doe je dat met het keyword abstract). In C++ doe je dat als volgt:

code:

virtual void virt_func()=0;

[Orphix]

Op donderdag 20 september 2001 22:17 schreef whoami het volgende:
Je kan ook uw virtuele functie in de base-class pure virtual maken, dwz dat ze in de Base class niets doet. (In Java doe je dat met het keyword abstract). In C++ doe je dat als volgt:

code:

virtual void virt_func()=0;

Let op, dit heeft tot nadelig/voordelig gevolg dat je geen instanties van die (base-)class kan creeren. Zulke classes worden dus gebruikt waarbij je MOET overerven.

[whoami]

Op donderdag 20 september 2001 22:41 schreef Orphix het volgende:

[..]

Let op, dit heeft tot nadelig/voordelig gevolg dat je geen instanties van die (base-)class kan creeren. Zulke classes worden dus gebruikt waarbij je MOET overerven.

Dit is helemaal niet waar. Een pure virtuele functie belet je niet om een instance te creeëren van een class, die class is nl niet abstract, enkel de functie is abstract. Als je virtuele functies wilt gebruiken heb je zelfs een instance van je base-class nodig.