virtuale funktioner

Når man kalder en virtuel funktion så kalder man funktionen i det
instantierede objekt ikke i det erklærede objekt.

Jeg kommer lige med et eksempel !

example.h
---------

class P1
{
  public:
      void foobar();
};

class C1 : public P1
{
  public:
      void foobar();
};

class P2
{
  public:
      virtual void foobar();
};

class C2 : public P2
{
  public:
      virtual void foobar();
};

example.cpp
-----------

#include <iostream>

using namespace std;

#include "Example.h"

void P1::foobar()
{
  cout << "P1" << endl;
  return;
}

void C1::foobar()
{
  cout << "C1" << endl;
  return;
}

void P2::foobar()
{
  cout << "P2" << endl;
  return;
}

void C2::foobar()
{
  cout << "C2" << endl;
  return;
}

test.cpp
--------

#include <stdlib.h>

#include "Example.h"

int main(int argc,char *argv[])
{
  P1 *p1 = new P1();
  p1->foobar();
  P2 *p2 = new P2();
  p2->foobar();
  C1 *c1 = new C1();
  c1->foobar();
  C2 *c2 = new C2();
  c2->foobar();
  P1 *m1 = new C1();
  m1->foobar();
  P2 *m2 = new C2();
  m2->foobar();
  exit(EXIT_SUCCESS);
}

Forskellen er at:

m1->foobar(); // kalder P1 foobar fordi den ikke er virtual

m2->foobar(); // kalder C2 foobar fordi den er virtual

Ja - jeg ved godt at det er lidt svært at gennemskue.

Som hoved-regel bør alle metoder man planlægger at overide i en
sub-klasse erklæres virtual.

Det er ganske usandsyneligt at man vil ønske sig ikke-virtual effekten.

I sproget Java er alle metoder virtual uden undtagelse. Ikke noget
at rafle om.

Og et svar

Og så skal du i C++ huske, at hvis du ønsker at nedarve fra en klasse du laver, så skal du erklære destructoren virtual. Ellers risikerer du den forkerte destructor bliver kaldt.

forstår bare ikke fordelen ???... altså hvorfor bør man erklære dem virtual ??

hvorfor ikke bare kalde funktionen man vil uden at skulle tænke på at hvis man kalder en funktion i en klasse så bliver en anden funktion i en anden klasse kaldt istedet ?

Forskellen på virtual og ikke virtual kommer til udtryk når man har
en klasse B der arver fra klassen A og man instantierer som:

A *o = new B();

og kalder en metode:

o->f();

Ved en ikke virtuel f så vil A::f blive udført.

Ved en virtuel f så vil B::f blive udført.

Man vil så godt som altid have B::f udført - derfor virtual.

Så kan du synes at konstruktion med at sige:

basis klasse = afledt klasse

er mærkelig, men det er en meget brugt feature i objekt orienteret
programmering (GoF patterns etc.).

okai tak for hjælpen :)... på nuværende tidspunkt kan jeg ikke se hva jeg skal bruge det til hehe men det kommer nok når man kommer lidt mere ind i det :P