multiple base objects, real-life scenario.

[Paul]

In real life situation, do we ever come across a situation where we
would need two base objects in an object.
A snippet is worth 1000 words (: so...

class Base
{
};
class Derived1:public Base
{
};
class Derived2: public Base
{
};
class Dervied12:public Derived1, public Derived2
{
//two objects of Base
};
//typical, just no virtual derivation of Base
Just to set the point right, I know we can remove one Base by using
virtual, but that's exactly not the goal here, do we have case where
we need two Base objects, can we compare it with any real life
situation.
Is amphibian comes any way close to this???
your inputs are appreciated.

thanks,
-Paul.

[Thomas Matthews]

Paul wrote:

In real life situation, do we ever come across a situation where we
would need two base objects in an object.
A snippet is worth 1000 words (: so...

class Base
{
};
class Derived1:public Base
{
};
class Derived2: public Base
{
};
class Dervied12:public Derived1, public Derived2
{
//two objects of Base
};
//typical, just no virtual derivation of Base
Just to set the point right, I know we can remove one Base by using
virtual, but that's exactly not the goal here, do we have case where
we need two Base objects, can we compare it with any real life
situation.
Is amphibian comes any way close to this???
your inputs are appreciated.

thanks,
-Paul.

You are describing the Diamond Inheritance pattern.
This is described in the C++ FAQ. Searching the FAQ
before posting is a very good thing.
http://www.parashift.com/c++-faq-lit....html#faq-25.8

Try this one:
class Field {};
class Record {};

class Look_Up_Field
: public Field,
public Record
{
};

Given a table of records. A record is composed of one or
more fields.

Let there be a Look-up field. The Look-up Field is a _proxy_
for one or more data fields. The Look-up Field can be treated
as a single field in a record or as a record in another table.
Thus it has the behavior of both a single field and as a
record.
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book

[Paul]

bg*****@yahoo.com (Paul) wrote in message news:<d8**************************@posting.google. com>...

In real life situation, do we ever come across a situation where we
would need two base objects in an object.
A snippet is worth 1000 words (: so...

class Base
{
};
class Derived1:public Base
{
};
class Derived2: public Base
{
};
class Dervied12:public Derived1, public Derived2
{
//two objects of Base
};
//typical, just no virtual derivation of Base
Just to set the point right, I know we can remove one Base by using
virtual, but that's exactly not the goal here, do we have case where
we need two Base objects, can we compare it with any real life
situation.
Is amphibian comes any way close to this???
your inputs are appreciated.

thanks,
-Paul.

Yes multiple inheritance is common.
If you are familiar with java you will know about implementing
intefaces.
In C++ Interfaces are called ADT's (abstract data types).
The best example I can think of is the platform specific ATL and COM
where multiple Interfaces are used.
Consider this:
/*Interfaces*/
class Imechanical{
};
class Ibiological{
};
class ILandThing{
};
class ISeaThing{
};

/*classes which use Interfaces*/
class Truck: Imechanical, ILandThing{
};
class AmphibiousTruck: Imechanical,ILandThing, ISeaThing{
};
class Salmon: Ibiological, ISeaThing{
};
class LungFish: Ibiological, ILandThing, ISeaThing{
};

perhaps the Imechanical interface has a needs_oil property and the
Ibiological has a bool property needs_to_reproduce :-)
then these methods are inherited by implementing the appropriate
Inteface.

As I said this is a major concept in Java and also in C# but in C++ it
seems only to be common in specialized areas.

I think it demands a different type of understanding from the basic
C++, a bit like templates, but that's only my perception. I'm sure we
all have different angles of looking at different types of code
solutions. For example:
How do you see this?
class Base{};
class Derived:Base{};
Base* pb = new Derived;
static_cast<Dervied* >(pb);

Do you think of it as casting down or casting up ?

I naturally think of it as casting up as it's being cast to a
superior, or more complicated, object. But I think the general C++
programming community would call it casting down. I'm not 100% sure on
this it's just a book I am reading uses this term in this way. It'd be
appreciated if you could clear this up.

HTH & HTIC
Paul.

[Thomas Matthews]

Paul wrote:

Thomas Matthews <Th****************************@sbcglobal.net> wrote in message news:<Jk*****************@newssvr19.news.prodigy.c om>...

Paul wrote:

In real life situation, do we ever come across a situation where we
would need two base objects in an object.
A snippet is worth 1000 words (: so...

class Base
{
};
class Derived1:public Base
{
};
class Derived2: public Base
{
};
class Dervied12:public Derived1, public Derived2
{
//two objects of Base
};
//typical, just no virtual derivation of Base
Just to set the point right, I know we can remove one Base by using
virtual, but that's exactly not the goal here, do we have case where
we need two Base objects, can we compare it with any real life
situation.
Is amphibian comes any way close to this???
your inputs are appreciated.

thanks,
-Paul.
You are describing the Diamond Inheritance pattern.
This is described in the C++ FAQ. Searching the FAQ
before posting is a very good thing.
http://www.parashift.com/c++-faq-lit....html#faq-25.8

but I am not refering to Diamond Inheritance, I am just looking for a
scenario where we would need two base objects in a derived class. I am
afraid you got it wrong.

Your example _is_ diamond inheritance:
Base
/ \
Derived1 Derived2
\ /
Derived12
Hmm, if smells like a diamond pattern...
Perhaps you should say what you mean and mean what you say.

Try this one:
class Field {};
class Record {};

class Look_Up_Field
: public Field,
public Record
{
};

Given a table of records. A record is composed of one or
^^^^^^^^

more fields.

it should be composition and not inheritance.

If you look very close, I did not specify any inheritance
for class Record. I was giving you a real world example
which matched your query.

Your query was for examples of inheriting from multiple
base classes. That is what I presented.
Perhaps you should say what you mean and mean what you say.
clas Record class Record
^ {
Collection<Field> _fc;
}; Nope, that won't work. In databases, fields can be of more than
one type, such as strings, integers and floating point.

The _implementation_ would be:
class Record
{
Collection<Field *> _fc;
};
With pointers, one can use polymorphism and not care about the
details of each field.
and in your example Look_Up_Field, there are no base copies and is not
an example of Diamond pattern, since there is no common base, its just
half of that diamond. :)

Hmm, look at _your_ original post. Review mine.
I _never_ stated that Look_Up_Field was a diamond pattern.
I _never_ stated that there were base copies, just multiple inheritance.
You never stated anything about copies of base classes.
I stated that your example that you provided was an example of the
Diamond Inheritance pattern.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.comeaucomputing.com/learn/faq/
Other sites:
http://www.josuttis.com -- C++ STL Library book

[Victor Bazarov]

Thomas Matthews wrote:

Paul wrote:

Thomas Matthews <Th****************************@sbcglobal.net> wrote
in message news:<Jk*****************@newssvr19.news.prodigy.c om>...

Paul wrote:

In real life situation, do we ever come across a situation where we
would need two base objects in an object. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The key words here are "would need".
A snippet is worth 1000 words (: so...

class Base
{
};
class Derived1:public Base
{
};
class Derived2: public Base
{
};
class Dervied12:public Derived1, public Derived2
{
//two objects of Base
};
//typical, just no virtual derivation of Base
Just to set the point right, I know we can remove one Base by using
virtual, but that's exactly not the goal here, do we have case where
we need two Base objects, can we compare it with any real life
situation.

While this doesn't look like a question, it is a question. It begins
with "do we have case". So, the question was "Do we ever, in real life,
have a case where we'd need two Base objects in one 'Derved12'?
Hmm, look at _your_ original post. Review mine.
I am puzzled why you cared to reply. You apparently didn't understand
the question.
I _never_ stated that Look_Up_Field was a diamond pattern.
I _never_ stated that there were base copies, just multiple inheritance.
You never stated anything about copies of base classes.
Yes, he did.
I stated that your example that you provided was an example of the
Diamond Inheritance pattern.

Not necessarily. For all we know, 'Base' subobjects of 'Derived1' and
'Derived2' are not the same. You cannot claim diamond inheritance when
there _can_ be a difference between 'Base' subobjects in the same class.

It is not possible in C++, but essentially, the example boils down to

struct Derived : Base, Base {
Derived() : Base(some_argument_1), Base(some_argument_2) {}
};

The only way to simulate that in C++ is by using either containment:

struct Derived {
Base b1, b2;
Derived : b1(some_argument_1), b2(some_argument_2) {}
};

or intermediate derived classes:

struct D1 : Base {
D1() : Base(some_argument_1) {}
};

struct D2 : Base {
D2() : Base(some_argument_2) {}
};

struct Derived : D1, D2 {};

The question of this thread is, "do we ever need that in real life?"

The question _isn't_ "Is that a diamond inheritance?"

The question _isn't_ "How to prevent multiple base class objects?"

Victor

[Karl Heinz Buchegger]

Thomas Matthews wrote:

but I am not refering to Diamond Inheritance, I am just looking for a
scenario where we would need two base objects in a derived class. I am
afraid you got it wrong.

Your example _is_ diamond inheritance:
Base
/ \
Derived1 Derived2
\ /
Derived12
Hmm, if smells like a diamond pattern...
Perhaps you should say what you mean and mean what you say.

What Paul means is:
Have you ever encountered a situation where you *don't* want
a diamond pattern. i.E where

Base Base
| |
Derived1 Derived2
\ /
Derived3

is the correct solution.

(Paul correct me if I got it wrong)

For me the answer is: No. I never have encountered
such a situation.

--
Karl Heinz Buchegger
kb******@gascad.at

[Paul]

Victor Bazarov <v.********@comAcast.net> wrote in message news:<ah**************@newsread1.dllstx09.us.to.ve rio.net>...

Thomas Matthews wrote:

Paul wrote:

Thomas Matthews <Th****************************@sbcglobal.net> wrote
in message news:<Jk*****************@newssvr19.news.prodigy.c om>...

Paul wrote:

> In real life situation, do we ever come across a situation where we
> would need two base objects in an object. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The key words here are "would need".
A snippet is worth 1000 words (: so...
>
> class Base
> {
> };
> class Derived1:public Base
> {
> };
> class Derived2: public Base
> {
> };
> class Dervied12:public Derived1, public Derived2
> {
> //two objects of Base
> };
> //typical, just no virtual derivation of Base
> Just to set the point right, I know we can remove one Base by using
> virtual, but that's exactly not the goal here, do we have case where
> we need two Base objects, can we compare it with any real life
> situation.

While this doesn't look like a question, it is a question. It begins
with "do we have case". So, the question was "Do we ever, in real life,
have a case where we'd need two Base objects in one 'Derved12'?

Hmm, look at _your_ original post. Review mine.

I am puzzled why you cared to reply. You apparently didn't understand
the question.

I _never_ stated that Look_Up_Field was a diamond pattern.
I _never_ stated that there were base copies, just multiple inheritance.
You never stated anything about copies of base classes.

Yes, he did.

I stated that your example that you provided was an example of the
Diamond Inheritance pattern.

Not necessarily. For all we know, 'Base' subobjects of 'Derived1' and
'Derived2' are not the same. You cannot claim diamond inheritance when
there _can_ be a difference between 'Base' subobjects in the same class.

It is not possible in C++, but essentially, the example boils down to

struct Derived : Base, Base {
Derived() : Base(some_argument_1), Base(some_argument_2) {}
};

The only way to simulate that in C++ is by using either containment:

struct Derived {
Base b1, b2;
Derived : b1(some_argument_1), b2(some_argument_2) {}
};

or intermediate derived classes:

struct D1 : Base {
D1() : Base(some_argument_1) {}
};

struct D2 : Base {
D2() : Base(some_argument_2) {}
};

struct Derived : D1, D2 {};

The question of this thread is, "do we ever need that in real life?"

The question _isn't_ "Is that a diamond inheritance?"

The question _isn't_ "How to prevent multiple base class objects?"

Victor

We could also use templates
Example:-

template<class T>
class Base{};

template<class T>
class Derived1:Base<T>{};

template<class T>
class Derived2:Base<T>{};

template<class T1, class T2>
class MoreDerived: Derived1<T1>, Derived2<T2>{};
then instantiate like this:-
MoreDerived<int,double> md;
This combined with derived classes' different implementation of pure
virtual functions is what I was trying to explain in my other
wafflings abour ATL etc.

HTH
Paul.