методы Добавления к специализации шаблона

Question

У меня есть шаблонный класс C++, который предоставляет ряд методов, например

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

Теперь я хочу, чтобы выставить дополнительные методы к этому классу, если X == Y. Я сделал это по подклассам MyBuffer,

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

Теперь проблема заключается в том, что я хочу иметь возможность делать, например,

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

Но я не уверен, как это осуществить. Я пытался думать о конструкторах копирования, операторах преобразования и т. Д., Но мои навыки на C++, к сожалению, немного ржавые.

EDIT: Я хотел бы добавить, что создание этих объектов является относительно дешевым (а также, что не будет много), что означает, что было бы хорошо, чтобы сделать что-то вроде этого:

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

В вопрос заключается в том, как я могу определить такое преобразование. Я думаю, оператор преобразования должен быть в MyBuffer, но я хочу, чтобы он был доступен, только если X == Y.

Answer 1

Вам не нужен отдельный класс для представления особого поведения. Частичная специализация позволяет вам обрабатывать некоторые из случаев MyBuffer < X, Y > и давать им дополнительные методы.

Держите оригинальную декларацию MyBuffer < X, Y > и добавить:

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: мои последние строки не были очень полезны в конце концов, как отметил Georg в комментариях, поэтому я удалил их.

Answer 2

Возможно, что вы хотите, если method1 и method2 верните ссылку на *this. В противном случае вам понадобится либо выполнить преобразование, либо сделать method1 виртуальным.

Answer 3

Хитрость заключается в том, чтобы иметь MyRegularBuffer::method1, который вызывает MyBuffer::method1, то способ преобразования полученного MyBuffer<X,X> в 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

я бы на CRTP здесь:

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