complicated class question

[l2u]

I want to be able to call virtual function (vfunc) in two differents classes (one derived in another)..

for instance:

class derived {
public:
	derived() { }
	void run() { vfunc(); }
	
	virtual void vfunc() { }
};

class someclass : public derived {
public:
	someclass() { }
	void vfunc() { std::cout << "someclass virtual function called\n"; }
};


class baseclass : public someclass, public derived {
public:
	baseclass() { }
	void vfunc() { std::cout << "baseclass virtual function called\n": }
};

void main() {
	baseclass test;
	test.run(); //will print baseclass virtual..
	//how to call vfunc that is inside someclass with test.run();
	//is this possible?
}

In other words (I know it sounds complicated):
I want to be able to print "baseclass virtual.." and "someclass virtual.." from baseclass (test) by calling run.
The reasons I want to do this is i'm working on my thread class that will be derived in other classes with virtual functions, and they will
be derived into main class which will also have the same virtual function (thread class is used to create thread and call virtual function) and
I want to keep all data in the same class (main class with derived classes) so I wouldnt have to pass the reference to main thread to the other (worker) threads/classes.

I hope you know what I mean.. Thanks for help

[vart]

I don't know what do you want.
Here what you can get with easy

#include <iostream>

class base {
public:
	base() { }
	void run() { vfunc(); }
	
	virtual void vfunc() {std::cout << "base virtual function called\n"; }
};

class someclass : public base {
public:
	someclass() { }
	virtual void vfunc() { std::cout << "someclass virtual function called\n"; }
};


class derived : public someclass{
public:
	derived() { }
	virtual void vfunc() { std::cout << "derived virtual function called\n"; }
};

int main(void) {
	base test;
	test.run(); //will print baseclass virtual..
	someclass test2;
	test2.run();
	derived test3;
	test3.run();
	return 0;
}

And that is the output:

base virtual function called
someclass virtual function called
derived virtual function called

If you want some other output - could you explain the difference?

[l2u]

How to call vfunc in someclass from derived?

[vart]

you can make it not virtual

#include <iostream>

class base {
public:
	base() { }
	void run() { vfunc(); }
	
	void vfunc() {std::cout << "base vfunc function called\n"; }
};

class someclass : public base {
public:
	someclass() { }
	void vfunc() { std::cout << "someclass vfunc function called\n"; }
};


class derived : public someclass{
public:
	derived() { }
	void vfunc() { std::cout << "derived vfunc function called\n"; }
	void vfunc2(){someclass::vfunc();}
	void vfunc3(){base::vfunc();}
};

int main(void) {
	derived test3;
	test3.vfunc();
	test3.vfunc2();
	test3.vfunc3();
	return 0;
}

Output

derived vfunc function called
someclass vfunc function called
base vfunc function called

[l2u]

I know that but I want to call it virtual.

[twomers]

One question, why are you inheriting derived twice for someclass? There's no need. The functionality is already in baseclass from someclass.

class baseclass : public someclass
{
public:
	baseclass(){}

	void vfunc( void ) 
	{
		someclass::vfunc();
	}
};

I'm sure there's another way of doing it which I've forgotten

[l2u]

Seems like I figured out (happy):

struct A {
	void run() { f(); }
	virtual void f() { cout << "A::f()" << endl; };
};

struct B : A {
	void f() { cout << "B::f()" << endl;};
};

struct C : A {
	void f() { cout << "C::f()" << endl;};
};

struct D : B, C { };

int main() {
	D d;

	B *bp = &d;
	C *cp = &d;

	bp->run();
	cp->run();
	return 0;
}

C *cp = &d;
cp->run();

Whats the other way to do this instead with pointers?

[ZuK]

struct D : B, C { };

I wonder why you want to have A twice in D ?
google "deadly diamond of death"
Kurt

[ZuK]

BTW: a more common way to do "that" is

#include <iostream>
using namespace std;

struct A {
	void run() { f(); }
	virtual void f() { cout << "A::f()" << endl; };
};

struct B : A {
	void f() { cout << "B::f()" << endl;};
};

struct C : A {
	void f() { cout << "C::f()" << endl;};
};

int main() {
        A * bp = new B;
	A * cp = new C;

	bp->run();
	cp->run();
       
        delete bp;
        delete cp;
	return 0;
}

[CornedBee]

Taking your scenario at face value (a D object with two embedded A objects from different inheritance paths), the way to do it would be this:

int main() {
	D d;

	d.B::run();
	d.C::run();
	return 0;
}

[l2u]

What if I want to have more than one copy of some data members from the top level class, but only one copy of the others (in A class/struct)?

I have to separate base to base class and virtual base class?
How should I do this?

[CornedBee]

By splitting the class into parts and inheriting from one virtually and the other non-virtually. But the whole thing sounds fishy to me. Too complex. Try to simplify your design.