Freigeben von Code zwischen einer spezialisierten und nicht spezialisierten Templatestruktur

Question

Wie kann ich Code zwischen einer spezialisierten und nicht spezialisierten Version einer C++ - Klasse freigeben?

Hier ist ein konstruiertes Beispiel dafür, was ich versuche zu erreichen:

mit zur Verbindungszeit

#include <iostream> 
using namespace std; 

template <size_t n> struct Y { 
    int one() { return 1; } 
    int two(); 
}; 

template <> struct Y<1> { 
    int one() { return 11; } 
    int two(); 
}; 

template <size_t n> int Y<n>::two() { return one() * 2; } 

int main() { 
    Y<1> X; 
    cout << X.one(); 
    cout << X.two(); 
    return 0; 
} 

Dies schlägt fehl:

Undefined symbols for architecture x86_64: 
    "Y<1ul>::two()", referenced from: 
     _main in test-7c4ebe.o 

Allerdings, wenn ich die Y<1> X;-Y<2> X; ändern, Kompilierung erfolgreich Alles gut.

Mein Ziel hier war die Verwendung der Beispielimplementierung von two() für die spezialisierte und unspezialisierte Version der Klasse.

konnte ich wie so um dieses Problem mit Vererbung erhalten:

#include <iostream> 
using namespace std; 

struct mixin { 
    virtual int one() = 0; 
    int two() { return one() * 2; } 
}; 

template <size_t n> struct Y : public mixin { 
    int one() { return 1; } 
}; 

template <> struct Y<1> : public mixin { 
    int one() { return 11; } 
}; 

int main() { 
    Y<1> X; 
    cout << X.one(); 
    cout << X.two(); 
    return 0; 
} 

Aber ich denke, dass bei jedem Aufruf von Y<n>.two(), rechts eine unnötigen v-Lookup-Tabelle verursacht?

Gibt es eine Möglichkeit, Code zwischen der spezialisierten und unspezialisierten Version freizugeben, ohne die Vererbung zu missbrauchen und einen V-Table-Lookup-Aufruf auszuführen?

Answer 1

Sie müssen one Methode zu mixin überhaupt nicht hinzufügen. Haben Sie einfach mixin mit einer nicht-virtuellen two Methode, um seine Implementierung mit der abgeleiteten Klasse Y zu teilen und CRTP zu verwenden.

#include <iostream> 
using namespace std; 

template <class Derive> 
struct mixin { 
    int two() { return ((Derive *)this)->one() * 2; } 
}; 

template <size_t n> struct Y : public mixin <Y<n>> { 
    int one() { return 1; } 
}; 

template <> struct Y<1> : public mixin <Y<1>> { 
    int one() { return 11; } 
}; 

int main() { 
    Y<1> X; 
    cout << X.one(); 
    cout << X.two(); 
    return 0; 
} 

Answer 2

Sie können die eine Methode speciliaze anstelle der Klasse Spezialisierung:

template <size_t n> struct Y { 
    int one() { return 1; } 
    int two() { return one() * 2; } 
    int theird(); // declare only for Y<N> 
}; 

template <> 
int Y<1>::one() { return 11; } 

// only for Y<1> 
template <> 
int Y<1>::theird() { return one()*two();} 

Answer 3

Statt CRTP, können Sie es auch tun andersrum:

#include <iostream> 
using namespace std; 

template <size_t n> struct Y { 
    int one() { return 1; } 
}; 

template <> struct Y<1> { 
    int one() { return 11; } 
}; 

template <size_t n> 
struct mixin : Y<n> { 
    int two() { return Y<n>::one() * 2; } 
}; 

int main() { 
    mixin<1> X; 
    cout << X.one(); 
    cout << X.two(); 
    return 0; 
} 

Oder alternativ :

template <class P> 
struct mixin : P { 
    int two() { return P::one() * 2; } 
}; 

mixin<Y<1>> X;