struct B {
	virtual void f() const { cout <<"B::f" << endl; }
	void g() const {cout << "B::g" << endl; }
};

struct D:B
{
	void f() const { cout << "D::f" << endl; }
	void g() { cout << "D::g" << endl; }
};

struct DD:D
{
	void f() { cout << "DD::f" << endl; }
	void g() const { cout << "DD::g" << endl; }
};

void call(const B& b)
{
	b.f();
	b.g();
}

int main()
{
	B b;
	D d;
	DD dd;

	call(b);
	call(d);
	call(dd);

	b.f();
	b.g();

	d.f();
	d.g();

	dd.f();
	dd.g();
}

Dieser Code gibt folgendes aus:

B::f B::g D::f B::g D::f B::g B::f B::g D::f D::g DD::f DD::g

Soweit so gut, aber was mir nicht klar ist mit der Vererbung ist der folgende code:

class B1
{
public:
	virtual void vf() const { cout << "B1::vf()" << "\n"; }
	void f() const {cout << "B1::f()" << "\n"; }
};

class D1:B1
{
public:
	void vf() const { cout << "D1::vf()" << "\n"; }
	void f() { cout << "D1::f()" << "\n"; }
};

int main()
{
	B1 bb;
	bb.vf();
	bb.f();

	D1 dd;
	dd.vf();
	dd.f();

	return 0;
	keep_window_open();
}

Diese Ausgabe macht:

B1::vf() B1::f() D1::vf() D1::f()

Das mit der Überschreibung ist mir klar da es sich um eine virtuelle Funktion handelt. Aber wieso wird auch die Funktion f() in D1 überschreiben. Es sollte doch f() von B1 erben?

struct B {
	virtual void f() const { cout <<"B::f" << endl; }
	void g() const {cout << "B::g" << endl; }
};

struct D:B
{
	void f() const { cout << "D::f" << endl; }
	void g() { cout << "D::g" << endl; }
};

struct DD:D
{
	void f() { cout << "DD::f" << endl; }
	void g() const { cout << "DD::g" << endl; }
};

Noch ein Hinweis: Man kann nur virtual-Funktionen überschreiben. g() wird nicht überschreiben, sondern verdeckt.