Re: dependent inheritance?
* cerr:
On Jun 11, 2:15 pm, cerr <ron.egg...@gmail.com> wrote:
Hi There,
Am I able to define what class the current class is inherited from at
runtime in the constructor?
Let me try to make an example:
We got two mother classes Car and Bus with completely different
methods.
Now i would like to instance a new class, let's call it NewVehicle.
Now can I decide in NewVehicle's constructor what class it's inherited
from (Car or Bus) if i was gonna go like:
NewVehicle *MyInstance = NewVehicle(Car);
?
Right, So I came up with following solution for my problem
class A
class myB : A
class myC :A, Thread
class Reader : Thread
{
if (condition)
myB *InstB = new myB();
else
myC *InstC = new myC();
}
Hence I'd have A running in Reader's thread and C would be running in
its own thread right?
I'm just looking for a possibility to not let C running in the same
thread as A as A and Reader is existing already (A running in Reader's
thread)
Hm. The above code doesn't make sense as C++, nor do the questions make direct
sense. It's possible that you just have some terminology wrong, but I think it's
likely that you also have some concept bleed (vaguely understood concepts that
seem to be much the same), and perhaps even language bleed (mixing concepts and
ideas from two or more programming languages, like e.g. Java and C++).
So:
A *thread* is a current point of execution that moves through the code,
associated with a routine call stack. Standard C++ per the 1998 standard
(including the 2003 corrections) does not support more than one thread per
program, which means it must be done by way of currently non-standard library
functionality. Anyway multi-threading is an "advanced" topic, far beyond the
basics of understanding classes and inheritance.
A *class* is a type that you can create instances of. Each instance will
generally have one or more data *members*. If you have defined one or more
*constructors* for the class then one of them will be executed when you create
an instance, allowing you to establish initial values for the data members in
that instance, the *member variables*. And vice versa, calling a constructor
creates an instance, unless you use very low level language features to
circumvent this very tight coupling beween instance creation and constructor
invocations, which is much of the point of constructors.
A class definition does not directly contain executable code. A class may define
methods that contain executable code. You can call a method "on" an instance
(a pointer to the instance is then passed as a hidden argument to the method).
The term *method* is however just a language-independent vague notion. In
standard C++ terminology it is convenient to define "method" as a "non-static
member function that is not a constructor", but some people may prefer to define
it just as a "a member function that is not a constructor", because C++ static
member routines correspond to what in some languages are "static methods".
The above is just to point you in the right direction: you really need a textbook.
Or at least a tutorial. :-)
Cheers & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!