Re: dependent inheritance?
On Jun 11, 4:13 pm, "Alf P. Steinbach" <al...@start.no> wrote:
* 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 d=
irect
sense. It's possible that you just have some terminology wrong, but I thi=
nk 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 concep=
ts and
ideas from two or more programming languages, like e.g. Java and C++).
This is just pseudo code to demostrate what I plan to do.
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 pe=
r
program, which means it must be done by way of currently non-standard lib=
rary
functionality. Anyway multi-threading is an "advanced" topic, far beyond =
the
basics of understanding classes and inheritance.
I very well know what a thread is. I'm using the pthread library:
https://computing.llnl.gov/tutorials/pthreads/
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 mor=
e
*constructors* for the class then one of them will be executed when you c=
reate
an instance, allowing you to establish initial values for the data member=
s in
that instance, the *member variables*. And vice versa, calling a construc=
tor
creates an instance, unless you use very low level language features to
circumvent this very tight coupling beween instance creation and construc=
tor
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 i=
nstance
(a pointer to the instance is then passed as a hidden argument to the met=
hod).
The term *method* is however just a language-independent vague notion. In
standard C++ terminology it is convenient to define "method" as a "non-st=
atic
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++ s=
tatic
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. :-)
See above....