virtual

Jover

Um dein Beispiel fortzuführen:

Form* form;
form = new Form;
form->zeichne(); // ruft Form::zeichne auf
form = new Dreieck;
form->zeichne(); // rutf Dreieck::zeichne auf

bei einer virtuellen Funktion wird also erst zur Laufzeit entschieden, welche Funktion aufgerufen wird (immer die Funktion passend zum aktuellen Typ des Objekts). Das nennt sich Laufzeitpolymorphismus.
Es gibt auch noch nen Compiletime-polymorphismus, aber das geht jetzt zu weit.

BTW: Ich würde Form::zeichne als pure virtual deklarieren. Denn IMHO gibt es keine 'gute' implementierung zum zeichnen von 'irgendetwas'.

Erhard Henkes

Hier zwei Beispiele (abstrakt und kleines Beispiel):

#include <iostream>
#include <conio.h>
using namespace std;

class Basisklasse
{ 
  public: 
    virtual void virt_function() { cout << "Basis sagt Hallo" << endl; };
};

class Kindklasse1 : public Basisklasse
{ 
  public: 
    void virt_function() { cout << "Kind1 sagt Hallo" << endl; }
};

class Kindklasse2 : public Basisklasse
{ 
  public: 
    void virt_function() { cout << "Kind2 sagt Hallo" << endl; }
};

class Enkelklasse1 : public Kindklasse1
{ 
  public: 
    void virt_function() { cout << "Enkel1 sagt Hallo" << endl; }
};

class Enkelklasse2 : public Kindklasse2
{ 
  public: 
    void virt_function() { cout << "Enkel2 sagt Hallo" << endl; }
};

int main()
{
    Basisklasse  basis; 
    Kindklasse1  kind1;
    Kindklasse2  kind2;
    Enkelklasse1 enkel1;
    Enkelklasse2 enkel2;

    Basisklasse * pZeiger = &basis; // Zeiger vom Typ Basisklasse
    pZeiger->virt_function();

    pZeiger = &kind1;
    pZeiger->virt_function();

    pZeiger = &kind2;
    pZeiger->virt_function();

    pZeiger = &enkel1;
    pZeiger->virt_function();

    pZeiger = &enkel2;
    pZeiger->virt_function();

    getch();
}

#include <iostream>
#include <conio.h>
using namespace std;

class Person
{
  public:
    virtual void geldueberweisung(float geld){ cout << geld << " an Person " << endl; };
};

class Mitarbeiter : public Person
{
  public:
    void geldueberweisung(float geld){ cout << geld << " an Mitarbeiter " << endl; };
};

class Kunde : public Person
{
  public:
    void geldueberweisung(float geld){ cout << geld << " an Kunde " << endl; };
};

class Lieferant : public Person
{
  public:
    void geldueberweisung(float geld){ cout << geld << " an Lieferant " << endl;};
};

void zahlung(Person * x, float Summe)
{
    x->geldueberweisung(Summe);
}

int main()
{
    Lieferant a;
    Kunde b;
    Mitarbeiter c,d;

    zahlung( &a, 500 );
    zahlung( &b, 300 );
    zahlung( &c, 250 );
    zahlung( &d, 170 );

    getch();
}

surf. interessiert es doch eh nicht. hört auf ihn zu füttern

sicher interessiert mich das!!! ich probiere grad bissal rum;-)
dank erst mal...desto mehr ihr schreibt, desto besser!;-)

cu

Jover

Es hindert dich auch niemand, dich selbst zu informieren. Bei googel z.B.

Erhard Henkes

@surf. : Noch Fragen?

was heisst das:

Basisklasse * pZeiger = &basis;

heisst das einen zeiger auf die adresse von basis?

cu

surf. schrieb:

was heisst das:
Basisklasse * pZeiger = &basis;
heisst das einen zeiger auf die adresse von basis?

cu

Nein. Das heißt, dass du ein Noob bist

Zyrian

surf. schrieb:

was heisst das:
Basisklasse * pZeiger = &basis;
heisst das einen zeiger auf die adresse von basis?

cu

pZeiger ist ein Zeiger vom Typ Basisklasse mit der Adresse der Variable basis.

Student_ schrieb:

surf. schrieb:
was heisst das:
Basisklasse * pZeiger = &basis;
heisst das einen zeiger auf die adresse von basis?

cu
Nein. Das heißt, dass du ein Noob bist

Nana :p wir sind doch immer alle hilfsbereit und freundlich

davie

Zyrian schrieb:

surf. schrieb:
was heisst das:
Basisklasse * pZeiger = &basis;
heisst das einen zeiger auf die adresse von basis?

cu
pZeiger ist ein Zeiger vom Typ Basisklasse mit der Adresse der Variable basis.

pZeiger ist vom Typ "Zeiger auf Basisklasse" und zeigt auf basis.