Re: Compile time vs runtime?

From:

=?ISO-8859-1?Q?Erik_Wikstr=F6m?= <Erik-wikstrom@telia.com>

Newsgroups:

comp.lang.c++

Date:

Wed, 09 May 2007 21:03:09 GMT

Message-ID:

<hGq0i.40507$E02.16364@newsb.telia.net>

On 2007-05-09 22:13, desktop wrote:

Noah Roberts wrote:

desktop wrote:

Zeppe wrote:

Noah Roberts wrote:

Zeppe wrote:

desktop wrote:

Would either of these method not help me to generate a container
with different types at compile-time?

Is not possible to generate a container with different types at
compile-time. Everything is at compile-time is static, frozen.
Obviously, a container is not frozen, that is, you don't know all
the types of all the elements of an heterogeneus container before
actually launching the program.

True, but you can make a container that contains objects that
heterogeneously wrap any other object.

Yes, but the type of the wrapped object is to be determined at run-time.

Regards,

Zeppe

Just to be sure: If one writes runtime code it is possible to make a
heterogeneous container. As an example I have the following:

class Base {
...
};

class BaseOne : public Base {
...
};

class BaseTwo : public Base {
...
};

I can now make:

std::vector<Base*> bases;

Since I am using a pointer to a Base object I can still add BaseOne
and BaseTwo to the container since since they have Base as their base
class.

At runtime it will be decided which types are in the container.

Nope. What type is in the container is decided at compile time. That
type is pointer to Base.

Ok but the container is still heterogeneous since it can both contain
BaseOne and BaseTwo pointers even though is created for type Base pointer.

Not really, a true heterogeneous container can contain objects of
different types, in this case there is only one type and that is a
pointer to Base. What makes this work close enough as a heterogeneous
container is the fact that the pointer to Base does not have to point to
an object of type Base, it might just as well point to an object of a
type derived from Base (BaseOne or BaseTwo).

If the type Base have any virtual methods and you call any of them
through dereferencing a pointer to Base (or a reference) then dynamic
binding comes into play and makes sure that the correct method in the
derived class that the pointer actually points to is called.

However if you in one of the derived types adds a method (that did not
exist in Base) and try to call it using a pointer to Base it will not
work since Base does not have that method.

--
Erik Wikstr?m