Unit *unit = new Unit("Boyz", "Nahkämpfer", 265, 6);
	AbstractInfantry *ai = new AbstractInfantry(2);
	ai->setOwner(unit);
	Infantry *model1 = new Infantry(ai);
	model1->setOwner(unit);

dann muss bzw. will ich später einen zeiger auf eine einheit der das model anghört setzen. dazu habe ich in der klasse model die funktionen setOwner implementiert.

laut ausgabe von meinem programm (das natürlich abstürzt) bekomme ich aber folgendes bei einer abfrage der adresse:

OWNER-Abstr: 0x8115498 (durch das ai->setOwner(unit);)
OWNER-Model: 0x8115498 (durch das model1->setOwner(unit);)
OWNER-Abstr: 0x8115498 (durch das model1->setOwner(unit);)
0x8115498 (std::cout<<unit<<std::endl;)

der rest durch die eigentliche model->abfrage...
get OWNER-Abstr: 0x8116978
get OWNER-Model: 0x8116978
get OWNER-Abstr: 0x8116978
0x8116978

bei dieser abfrage:

std::cout<<unit<<std::endl;
 	std::cout<<model1->owner()<<std::endl;

class AbstractModel
{
	public:
		//hat in abstr. klassen nix zu suchen
// 		AbstractModel();

		void setOwner(Unit *owner) {std::cout<<"OWNER-Abstr: "<<owner<<std::endl; /*own_un = owner;*/};
		void setOwner(int owner) {own_id = owner;};

		int inline owner_id() {return own_id;};			// Unit-ID der Einheit der das Modell angehoert
		Unit inline *owner() {std::cout<<"get OWNER-Abstr: "<<own_un<<std::endl; return own_un;};			// Zeiger auf Einheit der das Modell angehoert

	private:
		Unit* own_un;
		int own_id;
};

class AbstractInfantry : public AbstractModel
{
	public:
		AbstractInfantry(double d) {base_diam = d;};
		double inline size() {return base_diam;};		// Base-Durchmesser

	private:
		double base_diam;
};

class Model
{
	public:
// 		Model(AbstractModel* base) {m = base;};				// Konstruktor aus bestehendem AbstractModel
// 		Model(Model* base) {this = base;};				// Konstruktor aus bestehendem AbstractModel

		void	inline	select(bool s)	{sel = s;};
		bool	inline	selected() {return sel;};			// ist das Modell gerade selektiert?
		void	inline	sMove(bool m)	{mov = m;};
		bool	inline	moving() {return mov;};				// wird das Modell gerade bewegt?
		int	inline	owner_id() {return m->owner_id();}	;	// Unit-ID der Einheit der das Modell angehoert
		QPointF	inline	position() {return pos;};			// Position des Modells auf dem Schlachtfeld, in Zollkoordinaten
		void	inline	setOwner(Unit *o) {std::cout<<"OWNER-Model: "<<o<<std::endl; m->setOwner(o);};
		Unit	inline	*owner()   {std::cout<<"get OWNER-Model: "<<m->owner()<<std::endl; return m->owner();};		// Zeiger auf Einheit der das Modell angehoert
		void	inline	move(double x, double y) {pos.setX(pos.x() + x); pos.setY(pos.y() + y);};		// relative Bewegung
		void	inline	set_position(double x, double y) {pos.setX(pos.x() + x); pos.setY(pos.y() + y);};	// absolute Positionsaenderung
		void	inline	set_position(QPointF p) {pos.setX(p.x()); pos.setY(p.y());};	// absolute Positionsaenderung

		virtual EModelType type() = 0;
		virtual double size() = 0;
		virtual double angle()= 0;
		virtual double height() = 0;
		virtual double width() = 0;
		virtual void face(double a) = 0;
		virtual void turn(double a) = 0;
		virtual void sTurn(bool t) = 0;
		virtual bool turning() = 0;

	private:
		QPointF pos;
		bool sel;
		bool mov;

		AbstractModel* m;
};

/* zusaetzliche Eigenschaften fuer auf dem Schlachtfeld befindliche Laeufer */
class Infantry : public Model
{
	public:
		Infantry(AbstractInfantry* base) {m = base;};

		double		inline	size()	{return m->size();};

		EModelType inline type() { return MT_INFANTRY; };

		double angle() {return -1;};
		double height() {return -1;};
		double width() {return -1;};
		void face(double a) {};
		void turn(double a) {};
		void sTurn(bool t) {};
		bool turning() {return -1;};

	private:
		AbstractInfantry* m;
};

was mich wundert ist, dass der zeiger auf die unit anscheinend nicht korrekt gespeichert wird und mir nicht völlig klar ist wie man das richten kann. kurioserweise hat dieser code solange funktioniert, bis ein bekannter einen absturz bekam und dann funktionierte es bei mir auch nicht mehr... sehr seltsam?!