Re: Independently partial interface implementation
Many people believe that mixing Generic Programming with
Polymorphism is a bad idea, because these concepts are very
different, orthogonal. Many programmers are quite sure these two
just do not work together. However, I think I know at least one
case when Generic Programming extends Polymorphism.
I have created a new pattern allows to implement not full interface,
but by parts. Then, combining the partial implementation you can
easily create specific types you need.
Example:
class AB {
public:
virtual int a() = 0;
virtual const char* b() = 0;
}:
template <class TBase> class ImplA1 : public TBase {
public:
virtual int a() {
return 1;
}
};
template <class TBase> class ImplA2 : public TBase {
public:
virtual int a() {
return 2;
}
};
template <class TBase> class ImplB1 : public TBase {
public:
virtual const char* b() {
return "10";
}
};
template <class TBase> class ImplB2 : public TBase {
public:
virtual const char* b() {
return "20";
}
};
Now we can construct new types combining partial implementations of
AB interface:
typedef ImplA1<ImplB1<AB>> A1B1;
typedef ImplA2<ImplB1<AB>> A2B1;
typedef ImplA1<ImplB2<AB>> A1B2;
typedef ImplA2<ImplB2<AB>> A2B2;
Any feedback very appreciated.
Hi Sergey,
Your pattern is very similar to the Decorator pattern and a C++
variant of it that normally goes under the name Mixin.
http://en.wikipedia.org/wiki/Decorator_pattern
http://en.wikipedia.org/wiki/Mixin
The base of your idea has been around for a while. See
http://www.drdobbs.com/cpp/mixin-based-programming-in-c/184404445
However, I think it's worthwhile discussing this way of combining
implementations. It touches the field of Aspect-Oriented Programming
that I believe is something powerful.
http://en.wikipedia.org/wiki/Aspect-oriented_programming
Other patterns related to your work that I highly recommend you to
take a look at are:
CRTP - http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
Policy pattern - http://en.wikipedia.org/wiki/Policy-based_design
NVI - http://en.wikipedia.org/wiki/Non-virtual_interface_pattern
A really good book working a lot with generics and polymorphism is
Modern C++ Design, by Andrei Alexandrescu
http://www.amazon.com/dp/0201704315
As for the feedback to you I can only say that I like this way of
programming that you do. However, I've never put it into production
code so I haven't seen the bad sides of it yet. Hopefully someone else
can provide you with that kind of experience.
Best regards,
Daniel
PS. Never forget the virtual destructor in your interfaces, not even
in examples. ;)
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]