métodos Agregando especialización de plantilla

Question

tengo una clase de plantilla de C++ que expone una serie de métodos, por ejemplo

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

Ahora, Quiero exponer métodos adicionales para esta clase si X == Y. I haber hecho esto subclasificando MyBuffer,

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

Ahora, el problema es que quiero ser capaz, por ejemplo

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

Pero no estoy seguro de cómo lograr esto. Traté de pensar en los constructores de copia, los operadores de conversión, etc., pero desafortunadamente mis habilidades en C++ están un poco oxidadas.

EDIT: Debo añadir que la creación de estos objetos es relativamente barato (y también, no va a suceder muy a menudo), lo que significa que estaría bien hacer algo como esto:

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

El La pregunta es, entonces, ¿cómo puedo definir la conversión de esa manera? El operador de conversión necesita estar en MyBuffer, creo, pero quiero que esté disponible solo si X == Y.

Answer 1

usted no necesita una clase separada para representar el comportamiento especial. La especialización parcial le permite tratar algunas de las cajas MyBuffer < X, Y > especialmente y darles métodos adicionales.

Mantenga su declaración original de mybuffer < X, Y > y añadir:

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 

Editar: mis últimas líneas no eran muy útil después de todo, como ha señalado Georg en los comentarios, así que los he borrado.

Answer 2

Es posible hacer lo que desee si method1 y method2 devuelven una referencia a *this. De lo contrario, tendrá que hacer una conversión o hacer que method1 sea virtual.

Answer 3

El truco es tener un MyRegularBuffer::method1 que llama MyBuffer::method1, a continuación, una forma de convertir la resultante MyBuffer<X,X> en 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

yo iría a CRTP aquí:

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