dodawania metod do szablonu specjalizacji

Question

Mam matrycy klasy C++, który udostępnia szereg metod, np

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

Teraz chcę narażać dodatkowe metody do tej klasy, jeśli X == Y. I zostało to zrobione przez podklasy MyBuffer,

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

Problem polega na tym, że chcę móc np.

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

Ale nie jestem pewien, jak to osiągnąć. Próbowałem myśleć o konstruktorach kopiowania, operatorach konwersji itp., Ale moje umiejętności w C++ są niestety trochę zardzewiałe.

EDIT: Dodam, że tworzenie tych obiektów jest stosunkowo tanie (a także, że nie nastąpi dużo), co oznacza, że ​​będzie OK, aby zrobić coś takiego:

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

The pytanie brzmi, jak mogę zdefiniować taką konwersję. Operator konwersji musi znajdować się w MyBuffer, ale chcę, aby był dostępny tylko, jeśli X == Y.

Answer 1

Nie potrzebujesz osobnej klasy do reprezentowania specjalny zachowanie. Częściowa specjalizacja umożliwia leczenie niektórych przypadków MyBuffer < X, Y > i nadawanie im dodatkowych metod.

Zachować oryginalne deklarację MyBuffer < X, Y > i dodać to:

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: moje ostatnie linie nie były bardzo przydatne po wszystkim, jak podkreślił Georg w komentarzach, więc je usunąłem.

Answer 2

Możliwe jest robienie tego, co chcesz, jeśli method1 i method2 zwrócą numer referencyjny do *this. W przeciwnym razie musisz wykonać konwersję lub sprawić, że stanie się ona wirtualna.

Answer 3

Sztuką jest mieć MyRegularBuffer::method1 który wywołuje MyBuffer::method1, to sposób na konwersję powstałego MyBuffer<X,X> w 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

pójdę do CRTP tutaj:

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; } 
};