méthodes Ajout à la spécialisation du modèle

Question

J'ai une classe basé sur un modèle C++ qui expose un certain nombre de méthodes, par exemple

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

Maintenant, je veux exposer d'autres méthodes à cette classe si X == Y. Je l'ai fait par le sous-classement MyBuffer,

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

Maintenant, le problème est que je veux être en mesure de faire par exemple

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

Mais je ne suis pas sûr de savoir comment accomplir cela. J'ai essayé de penser à des constructeurs de copie, des opérateurs de conversion, etc., mais mes compétences C++ sont malheureusement un peu rouillées.

EDIT: Je dois ajouter que la création de ces objets est relativement pas cher (et aussi, il ne se produira pas beaucoup), ce qui signifie qu'il serait correct de faire quelque chose comme ceci:

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

Le question est alors, comment puis-je définir la conversion comme ça. L'opérateur de conversion doit être dans MyBuffer, je pense, mais je veux qu'il soit disponible seulement si X == Y.

Answer 1

Vous n'avez pas besoin d'une catégorie distincte pour représenter le comportement spécial. Spécialisation partielle vous permet de traiter certains des cas MyBuffer < X, Y > spécialement et leur donner des méthodes supplémentaires.

Gardez votre déclaration originale de MonBuffer < X, Y > et ajoutez ceci:

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: mes dernières lignes ne sont pas très utiles après tout, comme l'a souligné Georg dans les commentaires, donc je les ai supprimés.

Answer 2

Il est possible de faire ce que vous voulez si method1 et method2 renvoient une référence à *this. Sinon, vous devrez effectuer une conversion ou créer un method1 virtuel.

Answer 3

L'astuce est d'avoir un MyRegularBuffer::method1 qui appelle MyBuffer::method1, puis un moyen de convertir l'MyBuffer<X,X> résultant 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

Je vais pour CRTP ici:

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