C++ Method-level inheritance?

I'm not sure of the ramifications of it but you might be able to define within the base class, two functions. One with the before stuff that you want to happen and the other a pure virtual that is called after in the primary function.

  class Base  {    public:    void DoSomething()    {      // The before stuff goes here.      ReallyDoSomething();    }    protected:    virtual void ReallyDoSomething() = 0;  }  class Derived : public Base  {    protected:    void ReallyDoSomething()    {      // The stuff after the DoSomething    }  }  Derived d;  d.DoSomething();

I haven't used C++ in a while and I don't even know if it'll compile. Just thought I'd throw it out there to see if it helps. I'm sure someone will correct me pretty quickly though. [wink]

Instead of making the public method the one which is virtual make a protected method which is and then call that from a normal public function. The protected method is then the one which is overridden in the sub-class



I'm pretty sure that's how I've done it in the past.

You have to call methods explicitly. Is this for an inheritance situation, or just something you want to do for every function in a particular isolated class? If its just the one class, just call the methods manually -- you may want to leverage some kind of RAII-based invoker object that you simply declare at the top of each function -- if the invoker object calls your "on enter" function in its constructor and your "on exit" function in the destructor, it will make the whole thing a bit cleaner, especially if you have multiple exit points (such as via exceptions).

If you're talking about an inheritance situation where you want to make sure any subclass of the base always calls a certain function first and last in any overridden virtual methods, the solution is generally to expose a non-virtual public form of the function, which itself calls the required on-entry function, then the virtual method, then the on-exit function. This frees the subclasser from having to remember to do this.

Can you clarify further, if neither of these suggestions are appropriate?

You can't do it with default C++ syntax, but you can do it if you have some syntactic sugar wrapped around it:


now, your class interface inherits from public_interface, and your class implementation from public_interface_impl.

Whenever someone wants to call your shielded_interface functions, they first have to call the method "access", which calls pre_access() before each call.

You can override pre_access (either the const or non-const versions -- I set it up so the non-const calls the const version if you don't override it) and have it do whatever you want.

post_access is a bit trickier, and it might require you to design your own custom calling convention to do it practically.

Not a yakk's solution is needlessly complicated. Listen to Phantom and Tstrimp.

Okay, cool, I'll give that a try. It would be nice if there was a way to make all functions call the "pre_access" function without having to define a "wrapper" function for each new real function, but I suppose that's as close as I'll get.

Thanks guys!