Re: Virtual method inlining
On Nov 9, 5:46 pm, Leigh Johnston <le...@i42.co.uk> wrote:
On 09/11/2012 22:35, 1 2 wrote:
On 9 nov, 10:39, Leigh Johnston <le...@i42.co.uk> wrote:
On 09/11/2012 07:12, 1 2 wrote:
On 8 nov, 18:28, Leigh Johnston <le...@i42.co.uk> wrote:
On 08/11/2012 20:15, 1 2 wrote:
And in the code that uses the polymorphic operations, we use a
template parameter, but make sure that it implements the interface =
by
using a static_assert that tests a std::is_base_of:
template<class Shape>
void DrawShape(Shape* s)
{
static_assert(std::is_base_of<IShape, Shape>::value,=
"Shape must
implement IShape");
s->Draw(200, 100);
}
I can definitely see this being used at large scale.
What is the point of doing that? The compiler doesn't know that D=
raw is
"final" so still requires dynamic (virtual dispatch) unless it knows
Shape is the most derived type; the "final" overrider in C++11 impro=
ves
the situation somewhat.
OK, then maybe it can be changed to the following to disable calling
through the vtable:
template<class Shape>
void DrawShape(Shape* s)
{
static_assert(std::is_base_of<IShape, Shape>::value, "Sha=
pe must
implement IShape");
s->Shape::Draw(200, 100);
}
Totally pointless.
Why? It accomplishes what I said earlier: combine the contracts
provided by runtime polymorphism with the fast (w/o virtual dispatch)
calls of compile-time polymorphism.
Pointless because you need the object that draws all the shapes to be
aware of all the different types of shapes which is a nonsense from a
design point of view.
No it doesn't need that. Where in this code:
template<class Shape>
void DrawShape(Shape* s)
{
static_assert(std::is_base_of<IShape, Shape>::value, "Shape must
implement IShape");
s->Shape::Draw(200, 100);
}
do you see awareness of all the different types of shapes? It's just
like the original runtime polymorphism and compile-time polymorphism
examples in my reply to Tobias M=FCller, except that I basically
combined the two into one.
C++ templates are great especially for things
such as generic containers/algorithms, traits and policies but you are
misusing them: you need to learn how to do proper OOP.
I know proper OOP. Normally I would just use runtime polymorphism and
no templates at all (in this case), but this is more of an
optimization issue (maybe premature optimization if the virtual call
overhead is negligible compared to the actual work of the method, but
not otherwise).