Re: Inheritance

Hi Al,

We're all getting a little more mature as time goes on (a mature).

My brain is all muddled up from a really stressful day, but I'll try to tell
you what I know (whatever that's worth). I think you are kind of missing
the point of inheritance. Inheritance happens in a class structure, not in
the actual object. I know some other examples have been thrown around here,
but let's try this:

Say I have some shapes. They all have some basic things then need to be
able to do like contain dimensions, draw themselves, etc. If I have
something like:

CShape

as a base class I can derive things like

class CCircle: public CShape;
class CRectangle: public CShape;
class CSquare: public CRectangle;

Thus, Circles, and Rectangles are kinds of shapes and Squares are kinds of
Rectangles (which area also shapes). You can define functions in your base
class that do basic things and make them virtual so they can be overridden
or make them pure virtual (assign them to 0) to force the derived class to
have to write an function for itself. For example, a Draw function would
work differently for a rectangle than it would for a circle. There is a
good "animal" where mammals, birds, and reptiles are kinds of animals,
eagles are kinds of birds, bears are kinds of mammals, etc., but hopefullly
you get the idea.

Now if I wanted to create a shape that was sort of like a circle and a
rectangle together I could do multiple inheritance:

class CTomShape: public CCircle, CRectangle

Then that new class would get all the functions of the original classes,
plus it could derive it's own. Most people try to stay away from multiple
inheritance mostly because it can get you into a lot of trouble, but also
because it's kind of confusing. I use it for stuff like:

class COrderQueue : public CWinThread, OrderStatusListener

where I want my COrderQueue class to be a thread (have the functionality of
CWinThread), but also have the functionality of a listener (our terminology
for our messaging system). Thus, the COrderQueue class has both the
functionality of a thread and is a listener a the same time. It is a thread
that listens.

I think you are have a container crisis.

It looks to me like you want to create some objects "called b's and c's"
that are all kinds of a's. It might be easiler if you described the
problem in something more than single letter variables. Anyway, you would
not want to do anything with any kind of array besides store a single kind
of object. For example, you use a CStringArray or CStringList to store
arrays or lists of CStrings. A CString is a kind of object. In the case
above, if CShape were derived from CObject (pretty likely idea) you could
use CObList to store an list of CShapes of any kind (circles, squares,
rectangles, etc.) You might do this for a drawing program, for example.
I'm getting confused by your next part. You could certainly derive object c
from b, but you would not do this to an array item. You would do that in
the whole class structure. The array is just storing something and all
somethings in the container have to have something in common (like be
CObjects at some level). You could assign values to your array based on the
value of another array item, but that wouldn't be deriving anything.

If you could put real names to your variables (like what are model are you
trying to build) it would be easier to solve the riddle. For example, try
to think of it as a "goes into" sort of thing. What is the relationship of
a, b, and c? Maybe if you do that piece it would be easier to try to figure
out how to help. What really confuses me about your example, is you call it
multiple inheritance, yet you really only have one level for each object.
'a' is a CObject, 'b' is a kind of 'a', and 'c' is a kind of 'b' which is a
kind of 'a'.

This is a good example using "employees" that might be an interesting read
for you:

http://www.cs.bu.edu/teaching/cpp/inheritance/intro/

Also a definition (with simple chart) of multiple inheritance:

http://msdn2.microsoft.com/en-us/library/6td5yws2.aspx

This info on MFC containers may also be useful to you:

http://www.softlookup.com/tutorial/vc++/vcu26fi.asp

You can also use STL containers as others have mentioned here. It's up to
you.

Tom

"Al" <Al@discussions.microsoft.com> wrote in message
news:B3E40A7D-0A13-430F-AEE6-FD2822ABFABF@microsoft.com...