Force calling base class virtual function down long chains

Question

My problem extends this problem with longer inheritance chains

This is my code:

////////// View ///////////////
class View{
public:
    void Render(){
        std::cout << "View::Render" << std::endl;
        render();
    }
protected:
    virtual void render() = 0;
};
////////// ImageView ///////////////
class ImageView : public View{
public:
protected:
    void render(){
        std::cout << "ImageView:render" << std::endl;
    }
};
////////// Sprite ///////////////
class Sprite : public ImageView{
public:
protected:
    void render(){
        std::cout << "Sprite:render" << std::endl;
    }
};
////////// Utility ///////////////
void Draw(View *vw){
    vw->Render();
}
////////// main ///////////////
int main(){
    std::cout << "... Draw ImageView ..." << std::endl;
    ImageView *imgvw = new ImageView;
    Draw(imgvw);
    delete imgvw;

    std::cout << "... Draw Sprite ..." << std::endl;
    Sprite *sp = new Sprite;
    Draw(sp);
    delete sp;
    
    return 0;
}

Actual Output:

.. Draw ImageView ...
View::Render
ImageView:render
... Draw Sprite ...
View::Render
Sprite:render

Required Output:

.. Draw ImageView ...
View::Render
ImageView:render
... Draw Sprite ...
View::Render
ImageView:render
Sprite:render

I'm trying to keep just one Base class public method that should call all virtual methods chain. Is something like this possible in C++?

Answer 1

Per this question (Can I call a base class's virtual function if I'm overriding it?), change your definitions like so:

class Sprite : public ImageView{
public:
protected:
    void render(){
        ImageView::render(); // this calls the superclass' virtual method
        std::cout << "Sprite:render" << std::endl;
    }
};

Answer 2

I've gone through and implemented what you want using nested class constructors. It's fairly ugly and has rather a lot of boilerplate, but I believe it does exactly what you want.

#include <string>
#include <iostream>

using namespace std;

class View
{
protected:
    class ViewRender
    {
    public:
        ViewRender(const View &v) 
        {
            cout << "ViewRender:constructor" << endl;
        }
    };

    // returns a reference to a temporary.  I'm not sure how to avoid doing this
    // the reference isn't actually used, and we can't pass it a reference to one
    // and have it populate it since the trick is in the constructor.

    virtual ViewRender &MakeRender() = 0;
public:
    void Render() { MakeRender(); }
};

class ImageView : public View
{
protected:
    class ImageViewRender : public View::ViewRender
    {
    public:
        ImageViewRender(const View &v) : ViewRender(v)
        {
            cout << "ImageViewRender:constructor" << endl;
        }
    };

    virtual ImageViewRender &MakeRender() { return ImageViewRender(*this); }
};

class Sprite : public ImageView
{
protected:
    class SpriteRender : public ImageView::ImageViewRender
    {
    public:
        SpriteRender(const View &v) : ImageViewRender(v)
        {
            cout << "SpriteRender:constructor" << endl;
        }
    };

    virtual SpriteRender &MakeRender() { return SpriteRender(*this); }
};

class AwesomeSprite : public Sprite
{
protected:
    class AwesomeSpriteRender : public Sprite::SpriteRender
    {
    public:
        AwesomeSpriteRender(const View &v) : SpriteRender(v)
        {
            cout << "AwesomeSpriteRender:constructor" << endl;
        }
    };

    virtual AwesomeSpriteRender &MakeRender() { return AwesomeSpriteRender(*this); }
};

int main()
{
    AwesomeSprite as;
    ImageView &iv = as;

    cout << "rendering AwesomeSprite..." << endl;
    as.Render();

    cout << "rendering Awesome (downcast to ImageView)..." << endl;
    iv.Render();

    system("pause");
    return 0;
}

Strictly speaking, I still don't think there's a way to force people to do it correctly, but with this approach, calling any renderer will automatically call all of the renderers below it (there is no way around this). A clever subclasser is still free to write his own Render subclass without deriving it from the Render class above it, but then he won't get all of that rendering behavior for free, so I think this does as close to what you want as is possible.

The rendering is done entirely in the constructors for the ---Render nested classes, taking advantage of the fact that chaining is always performed for constructors. The user needs only to supply a protected virtual function MakeRender which returns a renderer reference of the required type. The fact that the user only declares the MakeRender function more or less forces them to produce an instance of the class, and keeps them from doing render work outside of the constructor (which would defeat the purpose).

Answer 3

If you want the actions of ImageView::render() to be taken no matter what the derived version says, why not create a private, non-virtual ImageView::base_render() and call it from ImageView::Render() before or after the derived render()?

Answer 4

Decorator pattern could help here but again that's not precisely what you are looking for.