Question about interfaces

[sip.address]

Hi there,

When creating interfaces and implementations , the usual thing is doing
somethign like

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

class Imp1 : public Interface {
public:
void f();
void g();
};

So we can have Interface* if = new Imp1; and so on..

But we could also use private inheritance:

class Imp1 {
protected:
void f();
void g();
};

class Interface : private Imp1 {
public:
void f() { Imp1::f(); }
...
};

What are the advantages/disadvantages of each? I believe in both cases
a level of indirection happens (through the virtual table or calling
the base class function in the second case). But probably today
compilers do some optimizations?

Any advise?

Thanks!

protected:
void f();

[acehreli]

On Jun 28, 4:36*pm, sip.addr...@gma il.com wrote:
[...]

But we could also use private inheritance:

class Imp1 {
protected:
* void f();
* void g();

};

class Interface : private Imp1 {
public:
* void f() { Imp1::f(); }
* ...

};

What are the advantages/disadvantages of each?

Normally, interfaces have more than one implementation as in Cat and
Dog inheriting from the Animal interface. So your private
implementation inheritance wouldn't work.

I believe in both cases
a level of indirection happens (through the virtual table or calling
the base class function in the second case). But probably today
compilers do some optimizations?

Sometimes, when the actual type of the object is known at compile time
I guess. Otherwise, in general the actual type is not known without
the use of virtual function table.

At a recent ACCU Silicon Valley talk, Ulrich Drepper mentioned how
indirect calls like C++'s virtual functions hurt the CPU's caching
schemes. Something to keep in mind, but I am not getting rid of my
virtual functions yet... :)

Ali

[Daniel T.]

si*********@gma il.com wrote:

When creating interfaces and implementations , the usual thing is doing
somethign like

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

class Imp1 : public Interface {
public:
void f();
void g();
};

So we can have Interface* if = new Imp1; and so on..

But we could also use private inheritance:

class Imp1 {
protected:
void f();
void g();
};

class Interface : private Imp1 {
public:
void f() { Imp1::f(); }
...
};

Note, the above is effectively the same as composition.

class Imp1 {
public:
void f();
void g();
};

class Interface {
Imp1 imp;
public:
void f() { imp.f(); }
};

What are the advantages/disadvantages of each?

The old "inheritanc e versus composition" question. This isn't strictly a
C++ question. Do a Google search on that term and you will get a
plethora of opinions.

Any advise?

"Favor object composition over class inheritance" (GoF)

[acehreli]

On Jun 29, 7:16*am, "Daniel T." <danie...@earth link.netwrote:

sip.addr...@gma il.com wrote:

[...]

But we could also use private inheritance:

class Imp1 {
protected:
* void f();
* void g();
};

class Interface : private Imp1 {
public:
* void f() { Imp1::f(); }
* ...
};

Note, the above is effectively the same as composition.

class Imp1 {
public:
* *void f();
* *void g();

};

class Interface {
* *Imp1 imp;
public:
* *void f() { imp.f(); }

};

What are the advantages/disadvantages of each?

The old "inheritanc e versus composition" question.

Not in this case though. It would be that question if the OP swapped
the class names; so to get to your example:

class Impl {
Interface interface;
public:
void f() { interface.f(); }

};

where Interface would not be an interface anymore.

This isn't strictly a
C++ question. Do a Google search on that term and you will get a
plethora of opinions.

Any advise?

"Favor object composition over class inheritance" (GoF)

Makes sense, but not in this question because there is an interface
that the OP is talking about. For the other types of class inheritance
like "a car HAS-AN engine", yes, that's composition.

Ali

[Daniel T.]

ac******@gmail. com wrote:

"Daniel T." <danie...@earth link.netwrote:

sip.addr...@gma il.com wrote:

But we could also use private inheritance:

class Imp1 {
protected:
* void f();
* void g();
};

class Interface : private Imp1 {
public:
* void f() { Imp1::f(); }
* ...
};

Note, the above is effectively the same as composition.

class Imp1 {
public:
* *void f();
* *void g();

};

class Interface {
* *Imp1 imp;
public:
* *void f() { imp.f(); }

};

What are the advantages/disadvantages of each?

The old "inheritanc e versus composition" question.

Not in this case though.

Yes, even in this case. Don't get too caught up in the names the OP
happened to choose.

class A { };

class B : private A { };

is effectively the same as:

class A { };

class B { A a; }

The only case where it is different is if class B overrides some virtual
member-function of A that is called internally within A. Like this:

class A {
public:
void foo() { bar(); }
virtual void bar(); /* can be pure virtual */
};

class B : private A {
void foo() { A::foo(); }
virtual void bar();
};

The above is *not* equivalent to composition. Rather, it is equivalent
to delegation.