Compiletime Polymorphism

Hallo,

Was versteht man unter Compiletime Poymorphism? Kann mir das jemand anhand eines Beispieles erklaeren?

Thanks

Nexus

Polymorphie bedeutet: Du sprichst verschiedene Dinge einheitlich an, aber im Hintergrund werden unterschiedliche Aktionen ausgeführt. Es ist eine Form der Abstraktion, wobei dich die Implementierung im Hintergrund als Aufrufer nicht interessiert.

Zur Laufzeit wird Polymorphie über virtuelle Funktionen oder Funktionszeiger realisiert. Im weiten Sinne kann man auch darauf aufbauende Konzepte wie std::function dazu zählen.

// Dynamische Polymorphie mit virtuellen Funktionen
struct Base
{
    virtual ~Base();
    virtual int f() = 0;
};

struct X : Base
{
    virtual int f();
};

struct Y : Base
{
    virtual int f();
};

void dispatch(Base& obj)
{
    obj.f();
}

int main()
{
    X x;
    Y y;
    dispatch(x); // ruft X::f() auf
}

Zur Kompilierzeit gibt es mehrere Möglichkeiten zur Polymorphie. Oft ist damit Ducktyping durch Templates gemeint, aber auch andere Abstraktionsmechanismen wie Funktionsüberladung, Operatorüberladung, ADL oder Templatespezialisierung können als Polymorphie angeschaut werden.

// Statische Polymorphie mit Templates
struct X
{
    int f();
};

struct Y
{
    int f();
};

template <typename T>
void dispatch(T& obj)
{
    obj.f();
}

int main()
{
    X x;
    Y y;
    dispatch(x); // ruft X::f() auf
}

// Statische Polymorphie mit Überladung
struct X {};
struct Y {};

int f(X& obj);
int f(Y& obj);

int main()
{
    X x;
    Y y;
    f(x); // ruft f(X&) auf
}

// Statische Polymorphie mit Argument Dependent Lookup
namespace nx
{
    struct X {};
    int f(X&);
}

namespace ny
{
    struct Y {};
    int f(Y&);
}

int main()
{
    nx::X x;
    ny::Y y;
    f(x); // ruft nx::f(X&) auf
}

Ducktyping durch Templates?

habe noch eine beispiel aus einem anderen thread gefunden:

template <class Operator> 
class Calculator 
{ 
public: 
    int calculate(int i1, int i2) 
    { 
        return doOperation.operator()(i1, i2); 
    } 

private: 
    Operator doOperation; 
};

class Adder 
{ 
public: 
    int operator() (int i1, int i2) 
    { 
        return i1 + i2; 
    } 
};

class Multiplier
{ 
public: 
    int operator() (int i1, int i2) 
    { 
        return i1 * i2; 
    } 
};

Calculator<Adder> calc1; 
std::cout << calc1.calculate(2, 3) << std::endl;

SeppJ

Die ganzen Beispiel hier im Thread passen zwar auch sehr gut zum Begriff Polymorpie, aber wenn mir jemand im C++-Kontext mit dem Begriff "compiletime polymorphism" käme, würde ich zuallererst an statische Polymorphie mittels CRTP denken, welches hier noch nicht erwähnt wurde.