Re: Array of derived classes

Hello Michael!

On Apr 24, 1:36 pm, Michael Gr=FCnewald <michip...@yahoo.de> wrote:


d


As you've discovered, you can't, exactly, make an array
of various Bi's. And as you've speculated, and Paavo and
Kevin have replied, you can use an array of pointers to
achieve your goal.

The key point is that in c++ polymorphism is implemented
using pointers (and references). So a pointer to your
base class, A:

   A *pointer_to_A;

can point not only to an A, but also to a derived Bi:

   B1 b1;
   B2 b2;
   pointer_to_A = &b1; // points to a B1
   pointer_to_A = &b2; // now it points to a B2

Other object-oriented languages manage polymorphism
differently, but this is how c++ does it.

(For completeness, the other important piece of the
polymorphism puzzle is the use of virtual functions.
If class A defines a virtual member function, say,

   virtual void A::doSomething() { x = 0; }

and the derived classes, Bi, override doSomething() with
their own versions that do something different:

   void B1::doSomething() { x = 1; }
   void B2::doSomething() { x = 2; }

then calling doSomthing() through pointer_to_A:

   pointer_to_A->doSomething();

doesn't necessarily call A's version, A::doSomething(),
(which would set x to 0), but depends on to which type
of object pointer_to_A actually points. So if
pointer_to_A points to a B1, then x will get set to 1
rather than to 0.)


But this constraint is perfectly fine if you use an
array of pointers. The conventional c++ jargon for
your non-instantiatable base class is an "abstract base
class." The derived classes that can be instantiated
are typically called concrete classes.

It's perfectly fine for A to be an abstract base class
and have a variable of type pointer-to-A (or an array
of pointers to A). These can point to instances of the
concrete derived classes, Bi.


Yes, pointers are the way to go to get heterogeneous (in the
sense of polymorphic) arrays. That's how c++ is designed to
work.

(Of course, as Paavo and Kevin mentioned, you might want
to use some fancier and "better" container such as a
std::vector instead of an array, and you might want
to use a fancier and "smarter" pointer such as a
std::shared_pointer instead of a raw pointer, but the
basic issue -- that c++ uses pointers (and references)
for polymorphism is still the same.)


A good place to start, especially if you are new to c++, is
Marshall Cline's C++ FAQ-Lite:

   http://www.parashift.com/c++-faq-lite/

His sections on inheritance, starting with:

   http://www.parashift.com/c++-faq-lite/basics-of-inheritance.html

are relevant, and he gives a synopsis of c++ polymorphism in:

   http://www.parashift.com/c++-faq-lite/virtual-functions.html#faq-20.2

(The C++ FAQ Lite is worth reading in general -- both to
look up answers to specific questions, and to browse just
for inspiration and general learning. It is not, however,
in any sense complete, so it's not really a good tutorial,
and is certainly not a comprehensive reference.)


Good luck, and Happy Hacking!

K. Frank