polimorfizm a dziedziczenie wielokrotne

witam, mam taki kod:

 
class maciek
{
///////
public:
	virtual void Wirtualna() = 0;
}
class piotrek : public maciek
{
public:
	virtual void Wirtualna()
	{
		cout << "bla bla" << endl;
	}
}
class andrzej : public piotrek
{
private:
	int m;
public:
	void Wirtualna (int k, andrzej $ob)
	{
		cout << k + ob.m << endl;
	}
}
void WywolajWirt(maciek* k)
{
	k->Wirtualna;
}
int main()
{
	maciek* l;
	andrzej o;
	l = &o;
	WywolajWirt(l);
}

Chciałbym żeby wywołała się definicja metody Wirtualnej z klasy andrzej a nie z klasy piotrek tak jak to robi kompilator (nawet jeżeli definicja funkcji w klasie piotrek jest pusta) idzie coś takiego wykonać?

k->Wirtualna; niczego nie wywołuje, bo nie ma tu ()...

I co to jest $ob? :)

I co to za nazwy klas? Jakaś rodzina??? :)

Pomijając to, że to syntaktycznie nie jest kodem C++, o czym wspomniał @koszalek-opalek...

Po pierwsze nie ma tutaj żadnego dziedziczenia wielokrotnego. Byłoby gdybyś miał

class andrzej : public piotrek, public maciek

Po drugie nie ma polimorfizmu, bo

virtual void Wirtualna()

a

void Wirtualna (int k, andrzej $ob)

to przeciążone metody o tej samej nazwie, a nie polimorficzne metody.

to zapytam inaczej jak "głęboko" w pokoleniu sięga polimorfizm chodzi mi o coś takiego:

klasa 1 (klasa abstrakcyjna z funkcja wirtualna)
klasa 2 : public klasa 1 (zawiera definicję1 funkcji wirtualnej)
klasa 3 : public klasa 2 (zawiera definicję2 funkcji wirtualnej)

teraz chciałbym stworzyć wskaźnik klasy abstrakcyjnej który wskaże obiekt klasy 3 i dla niego wywoła funkcję wirtualna zgodną z definicją w klasie 3

Jeżeli rzeczywiście masz polimorficzne metody, to tak głęboko jak to tylko możliwe.

#include <iostream>
using namespace std;

struct maciek { virtual void Wirtualna() = 0; }; 

struct piotrek : public maciek
{
    virtual void Wirtualna() override { cout << "piotrek" << endl; }
};

struct andrzej : public piotrek
{
    void Wirtualna() override { cout << "andrzej" << endl; }
};

void WywolajWirt(maciek* k)
{
    k->Wirtualna();
}

int main()
{
    andrzej o;
    maciek* l = &o;
    WywolajWirt(l);
}

Ad1: Widać, do czego się przydaje override. Gdybyś w swoim kodzie miał override to kompilator by od razu zaprotestował, że Wirtualna w andrzeju nie przesłania żadnej metody wirtualnej z klasy bazowej.
Ad2: Jeżeli masz metodę wirtualną, to należy również zdefiniować destruktor wirtualny.