Habe folgendes Bild vor Augen:

class A {
  public: 
     virtual void doThis ( void ) { /* ##CODE## */ }
};

class B {
  public: 
     void doThis ( void ) { /* ##Other CODE## */ }
};

B *b = new B;
b->dothis();

Kann ich auf irgend eine Art und weise auf das doThis() von A UND B zuzugreifen? Also dass beide aufgerufen werden.

Kann ich auf irgend eine Art und weise auf das doThis() von A UND B zuzugreifen? Also dass beide aufgerufen werden.

Du willst also über den Zeiger b die doThis der Klasse A und B aufrufen können? Nein, das geht nicht, da A und B nichts miteinander am Hut haben. Und selbst wenn B von A abgeleitet wäre, würde es nicht gehen, da Zeiger in einer Vererbungshierarchie nur nach unten zeigen können.

schade, dennoch danke

Wieso machst du kein richtiges Design?

class A
{
public:
	virtual void doThis ( void ) { std::cout << 'A'; }
};

class B : public A
{
public:
	void doThis ( void ) { std::cout << 'B'; }
};

void test(A& ref)
{
	ref.doThis();
}

int main()
{
	A a;
	test(a);

	B b;
	test(b);
}

(GoF-)Template Method Pattern:

class Base
{
public:

	void callBoth()
	{
		foo();
		foo_();
	}

	void foo() {}
	virtual void foo_() = 0; // oder auch nicht pure-virtual
};

class Derive : public Base
{
public:
		virtual void foo_() {}
};

int main()
{
	std::unique_ptr<Base> a(new Derive);
	a->callBoth();

	Derive d;
	d.callBoth();
}

so in etwa kann man sowas machen. die intention hinter dem template pattern sit zwar eigentlich eine andere, aber je nachdem was du vorhast könnte es dir helfen.

was hast du eigentlich vor? weil deinen post verstehe ich nicht so ganz, muss ich leider gestehen...

#include <iostream>

using namespace std;

class Base
{
public:

    virtual void foo() {cout << "** Base\n";}
};

class Derived : public Base
{
public:
    void foo() 
    {
    	Base::foo();
    	cout << "** Derived\n";
    }
};

int main()
{
    Base *b = new Derived;
    b->foo();
    cout << "-------\n";

    Derived d;
    d.foo();
}

Ausgabe schrieb:

B
A

Wird aber halt jedesmal beides aufgerufen.

naja, es kommt halt komplett drauf an was der TE haben will...

Ich hätte noch eine Idee, was er haben wollen könnte:

class A 
{
  public:
     virtual void doThis () { /* ##CODE## */ }
};

class B : public A
{
  public:
     void doThis () { /* ##Other CODE## */ }
};

int main()
{
    B *b = new B();
    b->doThis();
    b->A::doThis();
    delete b;
}