Mixing interface and functional inheritance

[Kevin L]

Below is a code snippet that fails to compile under vc.net

class BaseInterface
{
public:
virtual void f() = 0;
};

class BaseImplementat ion : public BaseInterface
{
public:
void f(){}
};

class ExtraInterface : public BaseInterface
{
virtual void g() = 0;
};

class ExtraImplementa tion: public BaseImplementat ion, public
ExtraInterface
{
void g(){}
};

void func()
{
ExtraImplementa tion d;
}

The compiler complains that ExtraImplementa tion is an abstract class
and therefore cannot be initialized. Function f, despite being
defined in BaseImplementat ion, is undefined in ExtraImplementa tion.

I hope it's clear what I'm trying to do, i.e., maintaining two
inheritance lines that parallel each other. One line consists of
interfaces and the other implementation. Am I misguided in my
efforts?

Kevin

[Alf P. Steinbach]

On 22 Sep 2003 17:39:26 -0700, in*****@hotmail .com (Kevin L) wrote:

Below is a code snippet that fails to compile under vc.net

class BaseInterface
{
public:
virtual void f() = 0;
};

class BaseImplementat ion : public BaseInterface
{
public:
void f(){}
};

class ExtraInterface : public BaseInterface
{
-- public:

virtual void g() = 0;
};

class ExtraImplementa tion: public BaseImplementat ion, public
ExtraInterfa ce
{
-- public:

void g(){}
};

void func()
{
ExtraImplementa tion d;
}

The compiler complains that ExtraImplementa tion is an abstract class
and therefore cannot be initialized. Function f, despite being
defined in BaseImplementat ion, is undefined in ExtraImplementa tion.
The compiler is correct.

In Java you can inherit a function spec from an interface, and an
implementation of that function from a concrete class. In C++ the
two inheritance chains are distinct, functions in one don't map
onto functions in the other, unless you use virtual inheritance,
which is both messy and a tad inefficient.

Instead of using virtual inheritance (the tech level solution) I
recommend _factoring out_ the ExtraInterface, like this:
class ExtraInterface
{
public:
virtual void g() = 0;
};
Now isn't that nice?

I hope it's clear what I'm trying to do, i.e., maintaining two
inheritance lines that parallel each other. One line consists of
interfaces and the other implementation.
You can do that as shown above.

I do not recommend the virtual inheritance alternative.
Am I misguided in my efforts?

Not enough information to say, but probably not; however, it seems
you come from a Java or perhaps C# background, and need to ditch
much of the low-level details from the previous language, while
holding on the high-level concepts (which you'll have to _implement_,
some times by adhering strictly to some convention, in C++).

[Gianni Mariani]

Kevin L wrote:

Below is a code snippet that fails to compile under vc.net

class BaseInterface
{
public:
virtual void f() = 0;
};

class BaseImplementat ion : public BaseInterface
{
public:
void f(){}
};

class ExtraInterface : public BaseInterface
{
virtual void g() = 0;
};

class ExtraImplementa tion: public BaseImplementat ion, public
ExtraInterface
{
void g(){}
};

void func()
{
ExtraImplementa tion d;
}

The compiler complains that ExtraImplementa tion is an abstract class
and therefore cannot be initialized. Function f, despite being
defined in BaseImplementat ion, is undefined in ExtraImplementa tion.

I hope it's clear what I'm trying to do, i.e., maintaining two
inheritance lines that parallel each other. One line consists of
interfaces and the other implementation. Am I misguided in my
efforts?

The virtual inheritance mechanism is what is intended to solve the problem.

class BaseInterface
{
public:
virtual void f() = 0;
};

class BaseImplementat ion : public *virtual* BaseInterface
{
public:
void f(){}
};

class ExtraInterface : public *virtual* BaseInterface
{
virtual void g() = 0;
};

class ExtraImplementa tion: public BaseImplementat ion, public
ExtraInterface
{
void g(){}
};

void func()
{
ExtraImplementa tion d;
}

[Kevin L]

al***@start.no (Alf P. Steinbach) wrote in message news:<3f******* *********@News. CIS.DFN.DE>...

On 22 Sep 2003 17:39:26 -0700, in*****@hotmail .com (Kevin L) wrote:

Below is a code snippet that fails to compile under vc.net

class BaseInterface
{
public:
virtual void f() = 0;
};

class BaseImplementat ion : public BaseInterface
{
public:
void f(){}
};

class ExtraInterface : public BaseInterface
{
-- public:

virtual void g() = 0;
};

class ExtraImplementa tion: public BaseImplementat ion, public
ExtraInterfa ce
{

-- public:

void g(){}
};

void func()
{
ExtraImplementa tion d;
}

....
Instead of using virtual inheritance (the tech level solution) I
recommend _factoring out_ the ExtraInterface, like this:
class ExtraInterface
{
public:
virtual void g() = 0;
};

....
Ah, but now I can't pass an object of ExtraImplementa tion as
ExtraInterface and have the BaseInterface functions available without
casting.

Now if I stick to strict abstract classes for the interfaces (no data
members), I can sidestep much of the messiness involved in virtual
inheritance, correct? The inheritance tree I am building is meant for
exception classes. I expect them to be constructed and used quite
infrequently. Right now I'm leaning toward the virtual inheritance
solution. Any reason not to?

Thanks for the reply.

Kevin

[Alf P. Steinbach]

On 23 Sep 2003 00:58:28 -0700, in*****@hotmail .com (Kevin L) wrote:

al***@start. no (Alf P. Steinbach) wrote in message news:<3f******* *********@News. CIS.DFN.DE>...

On 22 Sep 2003 17:39:26 -0700, in*****@hotmail .com (Kevin L) wrote:

>Below is a code snippet that fails to compile under vc.net
>
>class BaseInterface
>{
>public:
> virtual void f() = 0;
>};
>
>class BaseImplementat ion : public BaseInterface
>{
>public:
> void f(){}
>};
>
>class ExtraInterface : public BaseInterface
>{
-- public:

> virtual void g() = 0;
>};
>
>class ExtraImplementa tion: public BaseImplementat ion, public
>ExtraInterfa ce
>{

-- public:

> void g(){}
>};
>
>void func()
>{
> ExtraImplementa tion d;
>}
>

...

Instead of using virtual inheritance (the tech level solution) I
recommend _factoring out_ the ExtraInterface, like this:
class ExtraInterface
{
public:
virtual void g() = 0;
};

...
Ah, but now I can't pass an object of ExtraImplementa tion as
ExtraInterfa ce and have the BaseInterface functions available without
casting.

First, you _can_ hardwire the relationship, via an accessor method
in ExtraInterface.

But, second, why would you want to do that?
Now if I stick to strict abstract classes for the interfaces (no data
members), I can sidestep much of the messiness involved in virtual
inheritance, correct? The inheritance tree I am building is meant for
exception classes. I expect them to be constructed and used quite
infrequently . Right now I'm leaning toward the virtual inheritance
solution. Any reason not to?

1 In the most derived class you may have to call the constructor of
the root class.

2 Virtual inheritance mixed with non-virtual inheritance is very
messy. You're in for a maintainance nightmare.

3 It's a tad inefficient, also.