TITLE: Never redefine an inherited nonvirtual function

(This example taken from "Effective C++" by Scott Meyers, p. 130-132.)

Suppose I tell you that a class B is publicly derived from a class A,
and that there is a public member function mf defined in class A...
In other words, I say this:

	class A {
	  public:
		void mf ();
	  ...
	};

	class B : public A { ... };

Even without knowing anything about A, B, or mf, given an object x of
type B, 

	B x;			// B is an object of type x

you would probably be quite surprised if this,

	A* pA = &x;		// get a pointer to x
	pA->mf ();		// call mf through pointer

behaved differently than this:

	B* pB = &x;		/// get a pointer to x
	pB->mf ();		// call mf through pointer

That's because in both cases you're invoking the member function mf on
the object x. Because it's the same function and the same object in both
cases, it should behave the same way, right?

Right, it should. However, it might not. In particular, it won't if mf is
nonvirtual and B has defined it sown version of mf... The reason for this
two-faced behavior is that nonvirtual functions like A::mf and B::mf are
statically bound...

The bottom line, then, is that if you are writing class B and you redefine
a nonvirtual function mf that you inherit fromm class A, B objects will
likely exhibit schizophrenic behavior. In particular, any given B object
may act like either an A or a B when mf is called, and the determining
factor will have nothing to do with the object itself, but with the
declared type of the pointer that points to it. References exhibit the 
same baffling behavior as do pointers.