Hinzufügen von Methoden zur Vorlage Spezialisierung

Question

ich eine Templat C++ Klasse, die eine Reihe von Methoden aussetzt, zB

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

Nun, ich zusätzliche Methoden dieser Klasse verfügbar machen möchten, wenn X == Y. ich dies getan habe durch Unterklassen MyBuffer,

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

Nun ist das Problem, dass ich in der Lage sein möchte, z

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

Aber ich bin mir nicht sicher, wie dies zu erreichen ist. Ich habe versucht, an Kopierkonstruktoren, Konvertierungsoperatoren usw. zu denken, aber meine C++ - Kenntnisse sind leider ein wenig eingerostet.

EDIT: Ich möchte, dass die Schöpfung dieser Objekte hinzufügen relativ billig ist (und auch, es wird nicht viel passieren), was bedeutet, es wäre in Ordnung, so etwas zu tun:

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

Die Frage ist dann, wie kann ich die Konvertierung so definieren. Der Konvertierungsoperator muss in MyBuffer sein, denke ich, aber ich möchte, dass er nur verfügbar ist, wenn X == Y ist.

Answer 1

Sie benötigen keine separate Klasse brauchen das besondere Verhalten darzustellen. Teilspezialisierung ermöglicht es Ihnen, einige der MyBuffer < X, Y > Fälle speziell zu behandeln und ihnen zusätzliche Methoden zu geben.

Bewahren Sie die Originalerklärung MyBuffer < X, Y > und hinzufügen:

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: meine letzten Zeilen schließlich nicht sehr nützlich waren, wie von Georg in den Kommentaren darauf hingewiesen, also habe ich sie gelöscht.

Answer 2

Es ist möglich zu tun, was Sie wollen, wenn method1 und method2 einen Verweis auf *this zurückgeben. Andernfalls müssen Sie entweder eine Konvertierung durchführen oder method1 virtuell machen.

Answer 3

Der Trick ist eine MyRegularBuffer::method1 zu haben, die MyBuffer::method1 nennt, dann einen Weg, um die resultierende MyBuffer<X,X> in eine MyRegularBuffer<X> zu konvertieren:

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

würde ich für CRTP hier gehen:

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