Re: How many bytes per Italian character?
On Mon, 9 Apr 2007 15:10:04 -0700, "David Ching"
<dc@remove-this.dcsoft.com> wrote:
If you still have to document that derived classes need to call the base
pure virtual function, you really don't gain anything by having it pure
then.
As I explained, there was a set of these functions, and the derived classes
had to override and implement them all. Making them pure virtual ensured
that they did.
In fact, your documentation becomes pained having to explain that a)
even though the function is declared pure virtual, there is indeed a body
(which may or may not be visible in the header file), and b) the derived
class must be sure to call it from within the overridden function.
If it were not pure, but simply virtual, you do not have to explain a).
I think it's safe to say that not everyone shares your pain over this. In
any event, you have to weigh it against your alternative, which is to write
a set of parallel non-virtual functions.
(To put this in C# terms, I defined an interface, had the base class
implement it, and then had the derived classes reimplement it but still
call the base class as part of their implementation.)
This doesn't really apply. The derived class would be derived from the base
class and not the interface then.
I was thinking the C# approach would've looked like this (which is legal,
BTW):
interface IFace { void f(); }
class X : IFace {...} // Implements IFace
class Y : X, IFace {...} // Inherits X, reimplements IFace
My mistake was thinking that Y would have to implement all of IFace, but
that's actually not the case. Moreover, C# has very different behavior when
calling the function f through an IFace reference to Y vs. an X reference
to Y, when both X and Y implement f. I find the C# interface rules quite
arcane and obviously didn't review them thoroughly enough before posting.
If the C# code had worked as I thought <g>, the most directly analogous C++
solution would've looked like this:
struct IFace
{
virtual void f1() = 0;
virtual void f2() = 0;
};
struct X : IFace
{
// These have bodies but are redeclared pure. If you want to pick a nit,
// complain that you can't write the body of a pure virtual function in
// the class definition.
virtual void f1() = 0;
virtual void f2() = 0;
};
struct Y : X
{
virtual void f1() { X::f1(); ... }
virtual void f2();
};
That is what I did in my real code, except I didn't factor IFace out of X.
This is actually better than how the C# I proposed actually works, because:
1. To be concrete, Y has to implement the whole interface.
2. Calling f1 through a pointer to the IFace or X part of a Y has the same
effect.
This is way off-topic, but I would be interested in learning how to
accomplish this in C#.
--
Doug Harrison
Visual C++ MVP