Re: Am I using NVI?
In The C++ Programming Language 3rd ed. by Stroustrup, p.314 it explains
the use of pure virtual interfaces.
In C++ Coding Standards by Sutter & Alexandrescu it says:
Item 39: Consider making virtual functions nonpublic, and public
functions nonvirtual.
Usually I code something like this:
class Module
{
public:
virtual ~Module() {}
virtual void doThis() = 0;
virtual void doThat() = 0;
};
class BasicModule : public Module
{
public:
virtual void doThis() { /* ... */ }
virtual void doThat() { /* ... */ }
};
class SpecialModule : public BasicModule
{
public:
virtual void doThat() { /* ... */ }
};
NVI seems to be widely used and I just want to see if I need to abandon
my coding style for NVI.
If I consistently use BasicModule through out my application to define
the behavior, then what's the difference between my approach and NVI
except that I let subclasses override also the interface?
I think Item 39 explains it very well.
Benefits:
* The public interface is separated from the customization interface
* The base class is in control of when exactly the customization is
called and what should come before and after.
* Robust in the face of change
I like the idea of separating interface from implementation detail to
give one entity one responsibility. However, with NVI it will be
impossible to provide an alternative to the base class' implementation.
If I instead modify my approach shown above then it seems like I would
get the best of two worlds.
It would look like this:
class Module // Still the same
{
public:
virtual ~Module() {}
virtual void doThis() = 0;
virtual void doThat() = 0;
};
class BasicModule : public Module // Now imitates NVI
{
public:
virtual void doThis() { doThisImpl(); }
virtual void doThat() { doThatImpl(); }
private:
virtual void doThisImpl() = 0;
virtual void doThatImpl() = 0;
};
class SpecialModule : public BasicModule
{
private:
virtual void doThisImpl() { /* ... */ }
virtual void doThatImpl() { /* ... */ }
};
If there was a way to write
final virtual void doThis() { doThisImpl(); }
then this would be the optimal NVI solution.
I came up with this idea right now so please don't hesitate to criticize
it if you find any flaws.
So it all depends if you consider the overhead (more in code maintenance
terms and reading the code than in performance) worth the benefits.
I always go for maintenance in first hand.
br,
Martin
Daniel
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]