Re: What's polymorphic in CRTP
On 02/15/2013 03:03 PM, ?? Tiib wrote:
On Friday, 15 February 2013 19:25:10 UTC+2, Cholo Lennon wrote:
On 02/15/2013 02:05 PM, ?? Tiib wrote:
On Friday, 15 February 2013 18:55:12 UTC+2, Cholo Lennon wrote:
On 02/15/2013 01:33 PM, ?? Tiib wrote:
On Friday, 15 February 2013 18:18:47 UTC+2, Cholo Lennon wrote:
How about this?
It is example that works but does not achieve much else but inefficiency.
;-)
Why the example is inefficient? The call to Derived::onStatic is
resolved at compile time.
Because there are virtual functions (more expensive) that can not be used for
dynamic polymorphism (purpose is lost).
I explained it further. In my post that you quoted but apparently did not read.
and... have you read my explanation? This was an *example*, not a
production code. The idea was to show the dynamic and static variant in
a simple way.
I do not, yes, understand something here. Can you elaborate? Example must
be ideally simplest that works. Simpler than that is a lie, not example.
Someone may see it and think that it is showing how to mix dynamic and static
polymorphism, but it can't. What production code? I was saying that it should
be example on "never do like that" page with large red cross on it.
OMG, the OP asked for an example of static polymorphism with CRTP and
you gave him an example of static polymorphism with templates but
without CRTP! Nice way to teach the concept!
Just in case you insist with my example, I re-wrote it for you:
#include <iostream>
namespace dynamic_polymorphism
{
class Base {
public:
void callFoo()
{
onFoo();
}
virtual void onFoo()
{
std::cout << "Base::onFoo" << std::endl;
}
};
class Derived: public Base {
public:
virtual void onFoo()
{
std::cout << "Derived::onFoo" << std::endl;
}
};
}
namespace static_polymorphism
{
template<class T>
class Base {
public:
void callFoo()
{
T* pThis = static_cast<T*>(this);
pThis->onFoo();
}
void onFoo()
{
std::cout << "Base::onFoo" << std::endl;
}
};
class Derived: public Base<Derived> {
public:
// "pseudo virtual" function
void onFoo()
{
std::cout << "Derived::onFoo" << std::endl;
}
};
}
int main(int, char**)
{
dynamic_polymorphism::Derived der1;
der1.callFoo();
static_polymorphism::Derived der2;
der2.callFoo();
}
Are you happy now?
Regards
--
Cholo Lennon
Bs.As.
ARG