Re: Is the Mixin pattern accepted in all camps?
* DeMarcus, on 06.07.2010 21:15:
As I understand, Policies have been widely accepted, but is it the same
with Mixins? Or does people still believe Mixin is a bad way to avoid
Liskov's IS-A principle?
I can't think of any good ways to avoid the LSP (Liskov Substitution
Principle).
Whether it's done by a mixin or in some other way, it's generally bad.
Better to strive to honor the LSP.
My latest Mixin looks like this.
template<class T>
class CopyMixin
{
public:
typedef std::shared_ptr<T> SPtr;
SPtr copy() const
{
// Use NVI.
return copy_();
}
protected:
virtual SPtr copy_() const = 0;
};
class SomeClass : public CopyMixin<SomeClass>
{
private:
virtual SPtr copy_() const
{
SPtr c = /* Make a proper deep copy. */
return c;
}
};
Usually your "copy" is called "clone", it's like a de facto convention
in C++.
The C++ FAQ for some reason regards it as a special case of "virtual
construction" (the FAQ is the only place I've seen that term used for
that).
E.g., while clone() is typically implemented in terms of the copy
constructor,
one can imagine a newInstance() implemented in terms of the default
constructor.
What do you think about Mixins in general?
No strong feelings either way.
And if you have time, what do you think about above CopyMixin?
I think it's nice as an exercise, i.e. for learning about mixins, but it
doesn't
solve any of the following three problems of cloning in C++:
* Checking that cloning is properly implemented.
With the above it's difficult to assert anything about the clone_()
result, since if an override of clone_() is missing in some class,
then that missing override can not assert that it's missing.
* Providing a covariant result.
With the above the copy() result is always shared_ptr<TopMostBase>.
* Avoiding source code repetition of the clone implementation.
With the above every class must, redundantly, implement copy_().
(Maybe a better copy mixin is already invented. If you know of any,
please show me.)
The best I've come up with for cloning is a macro.
I discuss that and two other techniques that solve the three problems
above, at
<url:
http://alfps.wordpress.com/2010/06/12/cppx-3-ways-to-mix-in-a-generic-cloning-implementation/>.
I think you'll agree with me that of the three approaches (macro,
middle-man
base class and sideways inheritance with dominance in virtual
inheritance) the
macro wins in simplicity of usage and grokkability of implementation.
:-) But
perhaps there is some fourth and even fifth way. I wouldn't be surprised
if e.g.
Andrei Alexandrescu managed devise something that beats the macro.
Cheers & hth.,
- Alf
--
blog at <url: http://alfps.wordpress.com>
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]