Rzutowanie na wskaźnik innej klasy

Cześć. Problem dotyczy konwersji wskaźnika jednej klasy na drugą. Domyślam się, że brakuje operatora &, lecz nie spotkałem się z wykorzystaniem go w internecie - stąd prośba o pomoc. Poniżej zamieszczam prosty kod:

#include <iostream.h>
class Test {
	public:
		int a;
		Test () : a(0) {}
};

class Lol {
	public:
		int a;
		Lol () : a(0) {}
};

void fun (Test * test)
{
	cout << "obiekt wew fun przed operatorem = " << test->a << endl;
	test->a = 3;
	cout << "obiekt wew fun po operatorze = " << test->a << endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	Lol obiekt;
	obiekt.a = 9;
	cout << "obiekt przed fun: " << obiekt.a << endl;
	fun(&obiekt);
	cout << "obiekt po fun: " << obiekt.a << endl;
	cin.get();
	return 0;
}

Dziedziczenie niejako rozwiązuje problem kompilacji, ale wynik nie jest zgody z oczekiwaniem. Poza tym, czy jest w ogóle konieczne?

obiekt przed fun: 9
obiekt wew fun przed operatorem = 0 (powinno być 9)
obiekt wew fun po operatorze = 3
obiekt po fun: 9 (powinno być 3)

Prawdopodobnie kompilujesz jedno zaś uruchamiasz coś innego, tu dowód: http://ideone.com/S8M6bH
Ale stanowczo odradzam takiego użycia, po to istnieje dziedziczenie.

allucard018 napisał(a):

Wynik taki jak wyżej zamieściłem otrzymuje gdy dziedziczę po klasie Test (: public Test), zaś wszystko jest w porządku gdy użyje jawnej konwersji bez dziedziczenia tak jak Ty w przykładzie. Dlaczego tak się dzieje? ( link http://ideone.com/Scj3pL )

Ponieważ w tym przykładzie Test ma jedną składowa o nazwie "a" zaś Lol ma dwie składowe o nazwie "a", jedna z których odziedziczona po Test.

Wszystko fajnie, ale co jeżeli chciałbym np. użyć bardziej złożonej konwersji wskaźnika, np z małej klasy, której kod jest niżej na kombajn string nie chcąc tym samym dziedziczyć z niego. Jest taka możliwość?

#include <iostream.h>
using namespace std;

class Lol {
	public:
		char * napis;
		int rozmiar;

		Lol (const Lol & par) : napis(0)
		{
			this->operator =(par.napis);
		}
		Lol (string & buf) : napis(0)
		{
			this->operator =(buf.c_str());
		}
		Lol (const char * tekst) : napis(0)
		{
			this->operator =(tekst);
		}
		Lol () : napis(0), rozmiar(0)
		{
		}
		~Lol ()
		{
			delete napis;
		}
		operator = (const char * tekst)
		{
			rozmiar = strlen(tekst);
			delete napis;
			napis = new char [rozmiar + 1];
			napis[rozmiar] = 0;
			memcpy(napis, tekst, rozmiar);
		}
		operator string ()
		{
			string buf = napis;
			return buf;
		}
};


void fun (string * test)
{
	/* oczywiście wysyp programu :)
		cout << "obiekt wew fun przed operatorem = " << test->c_str() << endl;
		*test = "ufo enemy";
		cout << "obiekt wew fun po operatorze = " << test->c_str() << endl;
	*/
}

int _tmain(int argc, _TCHAR* argv[])
{
		Lol ufo = "tekscik";
		string napis = ufo;
		Lol obiekt = napis;

		cout << "obiekt przed fun: " << obiekt.napis << endl;
		fun((string*)(void *)&obiekt);
		cout << "obiekt po fun: " << obiekt.napis << endl;

		cin.get();
		return 0;
}

Dało by się coś takiego zrobić ale działało by tylko pod konkretną implementacją STL pod inną - nie koniecznie. Więc jeszcze raz powtarzam stanowczo odradzam.