On 2012-04-03 01:15, Joseph Rushton Wakeling wrote:
Hello all,
I'm coming to D from a background programming in C and C++, though I
wouldn't describe myself as an expert in either.
One of the C++ techniques I picked up over the last couple of years was
the use of policy classes, and I'm wondering how D addresses this issue
of combining various small components together to implement a given
interface.
D's interfaces seem an obvious starting point, but from the
documentation I've read, it seems like each implementation has to be
written separately. So, if I have an interface,
interface FooBar {
void foo();
void bar();
}
... I can of course write two different implementations,
class FooBarOne : FooBar {
override void foo() {
// Foo function implementation
...
}
override void bar() {
// Bar function implementation
...
}
}
class FooBarTwo : FooBar {
override void foo() {
// Foo function implementation
...
}
override void bar() {
// Bar function implementation
...
}
}
... but suppose that I'd like the foo() function to be identical in
both; how do I avoid rewriting the code?
In C++ I'd think of a policy class,
template <class Foo, class Bar>
class FooBar : public Foo, public Bar {
...
};
and then have,
typedef FooBar<FooGeneric,BarOne> FooBarOne;
typedef FooBar<FooGeneric,BarTwo> FooBarTwo;
... but I don't see how to do something equivalent with D's interfaces
and implementations. Can anyone advise?
Thanks and best wishes,
-- Joe
Maybe you could use template mixins to implement "foo".
mixin template Foo ()
{
void foo () {}
}
class FooBarOne : FooBar
{
mixin Foo;
}
--
/Jacob Carlborg
