Vererbung und Polymorphie

Hallo Leute,

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.

buxy schrieb:

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

buxy schrieb:

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);
}

Skym0sh0

doch klar geht das.

(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...

Belli

Vielleicht ist einfach so etwas gemeint:

#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();
}

#include <iostream>
using namespace std;

class A
{
public:
   virtual void doThis()
   {
		cout << "A" << endl;
   }
};

class B : public A
{
public:
   virtual void doThis()
   {
		cout << "B" << endl;
		A::doThis();
   }
};

int main()
{
	B b;
	b.doThis();
}

Ausgabe schrieb:

B
A

Wird aber halt jedesmal beides aufgerufen.

Skym0sh0

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

wxSkip

Skym0sh0 schrieb:

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;
}