struct context
{
	void render( widget & w )
	{
		w.render( *this ); //immediately calls do_render
	}
	template < typename widget_type > virtual void do_render( widget_type * ) = 0; //<-- error
};

main.cc:23: error: invalid use of `virtual' in template declaration of `virtual 
   void context::do_render(widget_type*)'

widget name    | used w/ base | implemented w/ derived | either
widget_1       | yes          | no                     | yes
widget_2       | no           | yes                    | yes
widget_3       | yes          | yes                    | yes
widget_4       | no           | no                     | no

base context vtable:

1 : do_render(  widget_1  ) : throw by default ( to be caught if misrendered )
2 : do_render(  widget_3  ) : throw by default ( to be caught if misrendered )

derived context vtable:

1 : do_render(  widget_1  ) : inherited, not overridden (throws if we try and use since never implemented
2 : do_render(  widget_3  ) : inherited, overridden (now does custom version since we implemented)
3 : do_render(  widget_2  ) : new (custom version we implemented)

Quote:Original post by MaulingMonkey
Now, this is a bit of a bummer. Any workarounds that spring to mind? I wouldn't have though this would be a problem since IIRC vtable building occurs at link time... after all the instantiations would be available...

Quote:Original post by SiCrane

Quote:Original post by MaulingMonkey
Now, this is a bit of a bummer. Any workarounds that spring to mind? I wouldn't have though this would be a problem since IIRC vtable building occurs at link time... after all the instantiations would be available...

In most compilers, the vtable is laid out at compile time, and the name bindings are resolved at link time.

In any case, the C++ standard specifically forbids virtual member function templates. I'm not entirely clear what you are trying to do, so I can't suggest a better solution for your problem.

struct sdl_context : public context{    void render( widget * w ) //inherits from context    {        if ( dynamic_cast< textbox * >( w ) ) {            //... render a textbox ...        } else if ( dynamic_cast< label * >( w ) ) {            //... render a label ...        } else if ( dynamic_cast< button * >( w ) ) {            //... render a button ...        } else {            throw error();        }    }}class render_into{    context & c;public:    render_into( context & c ) : c(c) {}    void operator()( widget * w ) { c.render(w); }};sdl_context my_sdl_context;std::list< widget * > widget_list;for_each( widget_list.begin() , widget_list.end() , render_into( my_sdl_context ) );

void sdl_context::do_render< textbox >( textbox * renderee ){    //render the textbox...}

Quote:Original post by Extrarius
It sounds almost like you want single dynamic dispatch(or whatever the proper name is), which you can easily implement as:
*** Source Snippet Removed ***
where render_self is a virtual function and thus each widget pointer will know the right one to call.

If not, perhaps further explaining exactly what you want would be helpful

struct context{    virtual void render ( widget & w ) { w.render( *this ); }    virtual void do_render ( textbox & t ) = 0;    virtual void do_render ( label & l ) = 0;};struct opengl_context : public context{    virtual void do_render( textbox & t )    {        //render textbox in opengl    }    virtual void do_render( label & l )    {       //render label in opengl    }};struct sdl_context : public context{    virtual void do_render( textbox & t )    {        //render textbox in SDL    }    virtual void do_render( label & l )    {        //render label in SDL    }};struct widget{    virtual void render( context & c ) = 0;); }};struct label : public widget{    virtual void render( context & c ) { c.do_render( *this ); }};struct textbox : public widget{    virtual void render( context & c ) { c.do_render( *this ); }};

Quote:Original post by SiCrane
Actually, it sounds like you want double dispatch.

Quote:It's a sufficiently complex subject in C++ that entire chapters of books can be devoted to it like chapter 10 in Alexendrescu's "Modern C++ Design." IIRC, Meyers also covers it in "More Effective C++." I don't know of any good online sources covering it. Sorry.