metodi Aggiunta di modello di specializzazione

Question

Ho una classe su modelli C++ che espone una serie di metodi, ad esempio

template<int X, int Y> 
class MyBuffer { 
public: 
    MyBuffer<X,Y> method1(); 
}; 

Ora, voglio esporre i metodi aggiuntivi per questa classe se X == Y. ho fatto questo sottoclassi MyBuffer,

template<int X> 
class MyRegularBuffer : public MyBuffer<X,X> { 
public: 
    MyRegularBuffer method2(); 
}; 

Ora, il problema è che voglio essere in grado di fare ad es.

MyRegularBuffer<2> buf = ... 
MyRegularBuffer<2> otherBuf = buf.method1().method2(); 

Ma non sono sicuro di come farlo. Ho provato a pensare a costruttori di copie, operatori di conversione, ecc., Ma le mie competenze in C++ sono sfortunatamente un po 'arrugginite.

EDIT: Vorrei aggiungere che la creazione di questi oggetti è relativamente a buon mercato (e anche, non accadrà molto), il che significa che sarebbe stato OK per fare qualcosa di simile:

MyRegularBuffer<2> buf = ... 
MyRegularBuffer<2> temp = buf.method1(); // Implicit conversion 
MyRegularBuffer<2> otherBuf = temp.method2(); 

Il la domanda è quindi, come posso definire la conversione in questo modo. L'operatore di conversione deve essere in MyBuffer, penso, ma voglio che sia disponibile solo se X == Y.

Answer 1

non hai bisogno di una classe separata per rappresentare il comportamento speciale. La specializzazione parziale ti consente di trattare alcuni dei casi di MyBuffer < X, Y > in modo speciale e di fornire loro metodi aggiuntivi.

Mantenete il vostro originale della dichiarazione di mybuffer < X, Y > e aggiungere questo:

template<int Y> 
class MyBuffer<Y, Y> { 
public: 
    MyBuffer<Y,Y> method1(); 
    MyBuffer<Y,Y> method2(); 
}; 

MyBuffer<1,2> m12; m12.method2(); // compile fail, as desired, as it doesn't have such a method because 1 != 2 
MyBuffer<2,2> m22; m22.method2(); // compile success 

Edit: miei versi finali non erano molto utile, dopo tutto, come sottolineato da Georg nei commenti, quindi li ho cancellati.

Answer 2

È possibile eseguire ciò che si desidera se method1 e method2 restituiscono un riferimento a *this. In caso contrario, sarà necessario eseguire una conversione o rendere virtuale method1.

Answer 3

Il trucco è quello di avere un MyRegularBuffer::method1 che chiama MyBuffer::method1, quindi un modo per convertire la risultante MyBuffer<X,X> in un MyRegularBuffer<X>:

template<int X> 
class MyRegularBuffer : public MyBuffer<X,X> 
{ 
public: 

    MyRegularBuffer<X>() 
    {} 

    MyRegularBuffer<X>(MyBuffer<X,X>) 
    { 
    // copy fields, or whatever 
    } 

    MyRegularBuffer<X> method2(); 

    MyRegularBuffer<X> method1() 
    { 
    MyRegularBuffer<X> ret(MyBuffer<X,X>::method1()); 
    return(ret); 
    } 
}; 

Answer 4

mi piacerebbe andare per CRTP qui:

template<int X, int Y, class Derived> 
struct MyBufferBase { 
    // common interface: 
    Derived& method1() { return *static_cast<Derived*>(this); } 
}; 

template<int X, int Y> 
struct MyBuffer : MyBufferBase<X, Y, MyBuffer<X,Y> > { 
    // basic version 
}; 

template<int X> 
struct MyRegularBuffer : MyBufferBase<X, X, MyRegularBuffer<X> > { 
    // extended interface: 
    MyRegularBuffer& method2() { return *this; } 
};