C++ Polymorphism/Abstraction. Multi-Class Abstraction.

[TamusJRoyce]

Hello. This is my first thread here.

My problem has probably been came across by a lot of people, but tutorials and things I've seen don't address it (usually too basic).

My problem is that I would like to use Abstraction for a "plug-in" like interface to classes.

class ThreadHandle
{
/* stuff here not yet dealing with threads */
 
/** Method which loops inside thread, when implemented */
virtual void update() = 0;
 
virtual void startThread() = 0;
virtual void stopThread() = 0;
}; // End ThreadHandle class
 
class ThreadTypeA : public ThreadHandle
{
/* stuff dealing with threads for linux */
 
protected: 
/** Thread function. */
static void *updateThread(void *input)
{ /* "input" refers to this class. 
* Loops input->update() function here */ } 
 
public:
virtual void startThread() { /* stuff specific to linux */ } 
virtual void stopThread() { /* stuff specific to linux */ } 
}; // End ThreadTypeA class
 
class ThreadTypeB : public ThreadHandle
{
/* stuff dealing with threads for windows */
 
public:
virtual void startThread() { /* stuff specific to windows */ } 
virtual void stopThread() { /* stuff specific to windows */ } 
}; // End ThreadTypeB class
 
class ThreadTypeC : public ThreadHandle
{
/* stuff dealing with emulated/fake thread */
static vector <ThreadTypeC *>emuThreads;
 
protected: 
/** Thread function. Runs all update()'s when ran */
static void *updateThread(void *input)
{ /* "input" is NULL. Loops through all elements
* in emuThreads, running update() */ } 
 
virtual void startThread() { /* stuff specific to faking */ } 
virtual void stopThread() { /* stuff specific to faking */ } 
}; // End ThreadTypeC class 
 
class Thread : public ThreadTypeA, public ThreadTypeB,
public ThreadTypeC
{ /** Stuff. This is probably a useless class. */ }; 
 
class BaseSystem : ThreadHandle
{
public:
/** Implements what update() does */
void update() { /* Important threading stuff */ }
}; // End BaseSystem class
 
int main()
{
BaseSystem testThreadTypeA, testThreadTypeB,
testThreadTypeC;
 
ThreadHandle *handleA = new ThreadHandleA();
ThreadHandle *handleB = new ThreadHandleB();
ThreadHandle *handleC = new ThreadHandleC();
 
// &testThreadTypeA = *handleA; // Error of course, but
// functionality I want.
// &testThreadTypeB = *handleB; // Error of course
// &testThreadTypeC = *handleC; // Error of course
 
return(1); // unsuccess because I'm stuck : P
}; // End main() Function
 

//...ThreadHandle
//..../...|...\........|
//...A...B...C...BaseSystem
//.....................|
//..................Derived, if any

I am wishing to make BaseSystem mimic a linux ThreadTypeA, windows ThreadTypeB, or emulated ThreadTypeC. The threads A-C need to use the virtual method update(), as well as BaseSystem needs to implement it.

Would making threadHandle inherit BaseSystem instead of the other way around take care of my problem?

But I need the end user (me and/or my wife) to have another class inherit BaseSystem, not ThreadHandle and have access to the thread... oh. virtual functions would take care of that. But still have problems

Here's an alternative way I'm still stuck...

//.......BaseSystem
//........./...........\
//....Thread....GraphicsSystem
//.......|
//.Types-of-Threads

class BaseSystem
{
public: // virtual for anything ThreadHandle and 
// BaseSystem needs access to. 
virtual void startThread() = 0;
virtual void stopThread() = 0;
 
/** Implements what update() does */
virtual void update() = 0;
}; // End BaseSystem class
 
/** Now ThreadHandle could be any name... */
class ThreadHandle : public BaseSystem
{
/* stuff here not yet dealing with threads */
 
}; // End ThreadHandle class
 
class ThreadTypeA : public ThreadHandle
{
/* stuff dealing with threads for linux */
 
protected: 
/** Thread function. */
static void *updateThread(void *input)
{ /* "input" refers to this class. 
* Loops input->update() function here */ } 
 
public:
virtual void startThread() { /* stuff specific to linux */ } 
virtual void stopThread() { /* stuff specific to linux */ } 
}; // End ThreadTypeA class
 
class ThreadTypeB : public ThreadHandle
{
/* stuff dealing with threads for windows */
 
public:
virtual void startThread() { /* stuff specific to windows */ } 
virtual void stopThread() { /* stuff specific to windows */ } 
}; // End ThreadTypeB class
 
class ThreadTypeC : public ThreadHandle
{
/* stuff dealing with emulated/fake thread */
static vector <ThreadTypeC *>emuThreads;
 
protected: 
/** Thread function. Runs all update()'s when ran */
static void *updateThread(void *input)
{ /* "input" is NULL. Loops through all elements
* in emuThreads, running update() */ } 
 
virtual void startThread() { /* stuff specific to faking */ } 
virtual void stopThread() { /* stuff specific to faking */ } 
}; // End ThreadTypeC class 
 
class GraphicsUpdatingSystem : public BaseSystem
{
int foo;
public:
GraphicsUpdatingSystem() { foo = 5; }
 
virtual void update() { /* finally implement update() */ }
int getFoo() const { return(foo); }
}; // End GraphicsUpdatingSystem class
 
int main()
{
GraphicsUpdatingSystem *gus;
 
// Error because gus inherits BaseSystem, but
// so does ThreadHandleA...
gus = new ThreadHandleA();
 
return(1); // unsuccess because I'm stuck : P
}; // End main() Function
 

//.......BaseSystem
//........./...........\
//....Thread....GraphicsSystem
//.......|
//.Types-of-Threads

Is a template the only way to solve this? That makes the executable so much bigger though. And getting GraphicsSystem to still implement update() is a problem too.

The diagram which I need is:

//...SystemA.....SystemB...SystemC......SystemZ
//.................\..........|.............|....... ........./
//..................\.........|.............|....... ......../
//...................-----BaseSystem--------
//..................................|
//......................-----Threadhandle----
//...................../.........|...........|..............\
//..................../..........|...........|...............\
//.......ThreadA...ThreadB....ThreadC.....ThreadZ

[HTML]
// where SystemA *systemA_ptr = new ThreadC();
// for example. But SystemA-Z is independent
// from one another, and ThreadA-Z is independent
// from one another.
[/HTML]

Thank you for any replies. Even if it's not helpful/relevant to solving this problem--a problem I've had for at least 5 years, but one way or another been able to avoid (mostly with less effective code).

And again, I am sorry for the length of this post. Any help on how I post (being a forum noob) would be appreciated too (like with formatting).


I'm currently running Gentoo Linux while I'm running samba to my wifes computer which is running micro$oft. She's in college while I've been out for a year. Both of us CS majors with some basic CIS classes, too.

My compilers are MinGW and GNU gcc. My IDE's are CodeBlocks, dev-cpp, gleany (linux), and notepad/xemacs.

[TamusJRoyce]

[HTML]
http://etutorials.org/Programming/Pr...4+Inheritance/
Some programmers speak of inheritance trees or hierarchies, but with multiple base classes, the organization of inheritance is a directed acyclic graph, not a tree. Thus, C++ programmers sometimes speak of inheritance graphs.
[/HTML]

Does this mean that if you have an indirect class inherited more than once, that the code size doesn't not increase, but rather links back to it? So it isn't a tree anymore, but a graph with no extra duplicated code?

I would love to see a link to an example. But I don't want someone to take up too much of their time on this.

[Banfa]

However I am sure there are plenty of people here who would be willing to help you.

Please remember to keep your examples down the the minimum, your question is rather longer than average (although at least it is an intelligent one as opposed to some collage kid looking for an answer involving no effort on their part) which may put off a few people. If you follow the "Help" link at the top of the page you will get to our posting guidelines but basically apart from length this post is formatted fine.

I believe the top experts in this forum (C/C++) are mainly from USA so you may have to wait a little for a reply but in the mean time I will give it a stab.


This

GraphicsUpdatingSystem *gus;
 
// Error because gus inherits BaseSystem, but
// so does ThreadHandleA...
gus = new ThreadHandleA();
 

can't work. You can only assign a pointer to an object to a pointer variable with a type of pointer to that object or pointer to a base class of that object.

class Base
{
<definition here>
}
 
class A : public Base
{
<definition here>
}
 
class B : public Base
{
<definition here>
}
 
int main()
{
Base *baseA = new A; // OK
A *AA = new A; // OK
Base *baseB = new B; // OK
B *BB = new B; // OK
A *AB = new B; // NOT OK
B *BA = new A; // NOT OK
}
 

For your original code this suggests 1 of 2 things to me (understanding that I don't really know what the software you have written does)

1. GraphicsUpdatingSystem should actually have a base class of ThreadHandleA, the code you have would still not be quite right though.
2. The design is wrong, GraphicsUpdatingSystem is either not an object but an instance of ThreadHandleA, or GraphicsUpdatingSystem is an object a part of the system and part of it is 1 (or more) ThreadHandleA object(s) in which case GraphicsUpdatingSystem does not want to have ThreadHandleA as a base class, or vice versa but rather GraphicsUpdatingSystem should contain 1 or more instances or the class ThreadHandleA that may need to be available through a class method (although that would break the class encapsulation)

In English my point is; is the Graphics Updating System a system part of which is a thread or is it a thread that is used to update the graphics. Depending on the answer the class should be designed appropriately.


In the later part of you post I think you are talking about inheriting multiple instances of a base class into a single class. Expanding my example hierarchy with

class C : public A, public B
{
<definition here>
}
 

Then C inherits A and through A a copy of Base and C also inherits B and through B another copy of Base. So C inherits Base twice. These are not the same class that is there are 2 discrete copies of the class Base with-in the definition of C resulting in

C c;
Base *pBase = &c; // Compiler error ambiguous conversion to Base *
 

The compiler can not covert to Base * directly because there are 2 copies of Base in the definition of C and it doesn't know which one you want a pointer to. You would ave to resolve it like this for instance

Base *pBase = static_cast<A *>(&c);
 

which forces the cast up a particular branch of the hierarchy resolving the ambiguity.


Your hour glass shaped hierarchy diagram does not feel right to be. It sounds like you want to be able to have ThreadType(T) on SystemType(S) but in that diagram BaseSystem does not represent a specific type of system but rather all types of system at the same time. For this reason I suspect it is wrong.

[TamusJRoyce]

Wow... I'm sorry for my mistake on byte magazine. But your input is really helpful. I see what you mean about my graph being wrong. And bearing with me though all the code.

I actually didn't expect a reply, considering the size of my post. Usually I can figure or research stuff on my own.

I've had this question since I started college. Though after a year of being out, finally running across it again.

I never thought of using a cast using multi-class inheritance. That solves a lot of my OO problems I've been having.

Is it static_cast or dynamic_cast in this case? Well, it'll give me something to research it on my own. nm. I can kinda see it's static_cast since it's at compiler time that it determines which class I'm wishing to inherit from.

Thank you a lot Banfa... If you ever need me, I'm in your debt.