class A
{
public:
  virtual void Funci(int z) { /* Mach was */ };
  A& operator<<(int z) { Funci(z); return *this; };
};

class B : public A
{
public:
  virtual void Funci(int z) { /* Mach was ganz anderes */ };
};

void DoIt()
{
  B* MyB = new B();
  MyB << 5;
}

Ich dachte virtual macht es möglich, dass bei meinen "MyB << 5" das Funci aus B aufgerufen wird. Bei mir wird aber das Funci aus A aufgerufen?!?!? Verstehe ich jetzt nicht. Liegt das am Operator oder an einem generellen Verständnisproblem von mir.

Danke,
Stefan

#include <iostream>
using namespace std;

class A
{
public:
  virtual void Funci(int z) { cout<<"A::Funci\n"; };
};
A& operator<<(A& a,int z) { a.Funci(z); return a; };

class B : public A
{
public:
  virtual void Funci(int z) { cout<<"B::Funci\n"; };
};

int main()
{
  B* MyB = new B();
  (*MyB) << 5;
}

edit:
oh, auch so:

#include <iostream>
using namespace std;

class A
{
public:
  virtual void Funci(int z) { cout<<"A::Funci\n"; };
    A& operator<<(int z) { Funci(z); return *this; };
};

class B : public A
{
public:
  virtual void Funci(int z) { cout<<"B::Funci\n"; };
};

int main()
{
  B* MyB = new B();
  (*MyB) << 5;
}

Was war nochmal das Problem?

edit2: Bei alten MS-Compilern mußte man gelegentlich this->Funci(z); aufrufen, wenn man verhindern wollte, daß der Compiler aus einer spaßigen Idee heraus das virtual ignoriert. Aber Du benutzt bestimmt keinen zehn Jahr alten Compiler.

MyB->operator<<(5);

Oder durch Dereferenzierung des Zeigers:

*MyB << 5;

Dann passiert auch /* Mach was ganz anderes */ . Das würde aber auch ohne vitual passieren, denn Du hast ein B*;
Der Witz an virtual ist

A* MyB = new B();
  *MyB << 5;

Dein Beispiel sollte eigentlich gar nicht kompilieren. MyB ist ein Zeiger und so müsste es heißen

MyB->operator<<(5);

Oder durch Dereferenzierung des Zeigers:

*MyB << 5;

Japp, den Stern hab ich beim Beispielschreiben vergessen. *forgiveme*

brotbernd schrieb:

Dann passiert auch /* Mach was ganz anderes */ . Das würde aber auch ohne vitual passieren, denn Du hast ein B*;
Der Witz an virtual ist

A* MyB = new B();
  *MyB << 5;

Ähm, nein, deswegen schreib ich ja. Ich habs gerade mit dem Debugger 5-6 mal ausprobiert. Ich lande dabei immer in Funci von A. Ich hab die Typen überprüft und die Zeiger geprüft.

Ähm, nein, deswegen schreib ich ja. Ich habs gerade mit dem Debugger 5-6 mal ausprobiert. Ich lande dabei immer in Funci von A. Ich hab die Typen überprüft und die Zeiger geprüft.

Welchen Compiler benutzt Du?
Falls MSVC:
Leg mal ein neues Projekt an und paste den Code dort rein. Ist dann dort das Verhalten immernoch befremdlich?
Anderenfalls:
Poste nochmal ein vollständiges Programm, das auch andere ohne Debugger nachvollziehen können, so mit cout wie bei mir, das bei Dir komische Ausgabe macht.

Ich hab aber bei mir gerade etwas anderes im Debugger gesehen:

MyB | 0x...
-> A | ...
--> __vfptr | const A::vftable

Das heisst ja wohl, dass ich beim Erzeugen der Klasse bereits die falsche virtuelle Funktionstabelle habe. Also ist mein oben genanntes Problem eigentlich keins und würde so funktionieren, wenn die richtige Tablle verwendet werden würde.

Ich erzeuge das Objekt durch:

// stark gekürzter Code...
A* temp = new B(); // Steht irgendwo in einer Funktion zur Objektverwaltung...
B* MyB = static_cast<B*>(temp); // Ist quasi der Rückgabewert....

Und da wirfts ihn. Habs auch schon mit dynamic_cast probiert, gleiches Problem. Wenn ich direkt mit new B() arbeite hab ich auch die richtige virtuelle Funktionstabelle-Tabelle.

Somit Entschuldigung für den nicht falschen Fehler und danke fürs mitdenken und euere Zeit.

Stefan

#include <iostream>
using namespace std;

class A
{
public:
    virtual void Funci(int z)
    {
        cout<<"A::Funci\n";
    };
    A& operator<<(int z)
    {
        Funci(z);
        return *this;
    };
};

class B : public A
{
public:
    virtual void Funci(int z)
    {
        cout<<"B::Funci\n";
    };
};

int main()
{
    A* temp = new B(); // Steht irgendwo in einer Funktion zur Objektverwaltung...
    B* MyB = static_cast<B*>(temp); // Ist quasi der Rückgabewert....
    *MyB << 5;
}

gibt auch B::Funci aus.

Danke trotzdem.

// stark gekürzter Code...

Object-slicing mit weggekürzt? Also sowas:

int main()
{
    A* temp = new B;
    machWas(*temp);
}
void machWas(A arg)
{
    B* MyB = static_cast<B*>(&arg);
    *MyB << 5;
}

gibt A::Funci aus.

Object-slicing mit weggekürzt? Also sowas:

int main()
{
    A* temp = new B;
    machWas(*temp);
}
void machWas(A arg)
{
    B* MyB = static_cast<B*>(&arg);
    *MyB << 5;
}

gibt A::Funci aus.

Das sieht von der Form her genau so aus, was ich mache. Ich sammel meine Objekte in einer Map mit <unsigned int, A*>. Und zurück geben tu ich es über einen cast.
Was ist das mit den Object-slicing?

Was ist das mit den Object-slicing?

http://lmgtfy.com/?q=object+slicing+c%2B%2B

stefanjann schrieb:

Was ist das mit den Object-slicing?

http://lmgtfy.com/?q=object+slicing+c%2B%2B

Danke und Entschuldigung, dass ich im Eifer des Gefechtes einfach mal ne Frage zu einem (für mich) neuem Bereich gestellt habe.

Ob mans glaubt oder nicht, gleich nach dem Absenden meines Beitrages hab ich sogar eine Suchmaschine befragt und mein Handbuch gezogen, noch bevor ich darauf hingewiesen wurde, dass es Google gibt.