Comment avoir deux (ou plus) instances d'un template typename class utilise la même fonction

Question

Je me demande s'il est possible d'avoir une classe qui utilise un template<typename T> avec des fonctions que le 'typename T' utilise par défaut. Je vais vous donner des exemples:

tête:

includes all here 
extern template class Object<rectangleBase> 
extern template class Object(circleBase> 

struct rectangleBase 
{ 
    int width, height; 
    int posX, posY; 
}; 

struct circleBase 
{ 
    int radius; 
    int posX, posY; 
}; 

template<typename T> 
class Object { 
public: 
    Object(); 
    ~Object(); 

    void movePos(int x, int y); 

    void setPos(int x, int y); 

    T& returnObject() { 
     return object; 
    } 
private: 
    T object; 
}; 

Source:

includes all here 
template class Object<rectangleBase> 
template class Object<circleBase> 

Object<rectangleBase>::Object() { 
    rectangleBase* newObject; 
    newObject = new rectangleBase; 
    object = *newObject; 
} 

Object<circleBase>::Object() { 
    circleBase* newObject; 
    newObject = new circleBase; 
    object = *newObject; 
} 

void Object::movePos(int x, int y) { //here 
    object.posX += x; 
    object.posY += y; 
} 

void Object::setPos(int x, int y) { //here 
    object.posX = x; 
    object.posY = y; 
} 

Avec les fonctions setPos et movePos, est-il possible que les deux <rectangleBase> et <circleBase> peuvent utiliser la même fonction au lieu de Je dois écrire deux fois le même code parce qu'ils utiliseraient exactement le même code, j'ai montré où les fonctions sont dans le code.

Si ce n'est pas possible, existe-t-il une alternative?

Answer 1

Avoir le même code pour plusieurs types de données différents (la programmation générique en un mot) est exactement ce que sont les modèles. Je pense que vous êtes trop penser à des choses.Ce qui suit est suffisant pour votre cas d'utilisation:

template<typename T> 
class Object { 
public: 
    Object() 
    : object() 
    { } 

    void movePos(int x, int y) { 
     object.posX += x; 
     object.posY += y; 
    } 

    void setPos(int x, int y) { 
     object.posX = x; 
     object.posY = y; 
    } 

    T& returnObject() { 
     return object; 
    } 
private: 
    T object; 
}; 

C'est tout ce dont vous avez besoin. Cela fonctionnera pour tout T qui est constructible par défaut, puis movePos et setPos peut être appelée si T a ces deux variables membres. Vous n'avez pas besoin de déclarer des spécialisations du tout. Compte tenu de ce qui précède, ce qui suit fonctionne bien:

Object<rectangleBase> r; 
r.setPos(5, 6); 

Object<circleBase> c; 
c.setPos(10, 20); 
s.movePos(10, 10); 

Answer 2

Oui, vous pouvez:

template <typename T> 
void Object<T>::movePos(int x, int y) { 
    object.posX += x; 
    object.posY += y; 
} 

Même vos constructeurs pouvez utiliser cette approche:

template <typename T> 
Object<T>::Object() { 
    // This in fact does nothing really different than the default 
    // constructor of object but leaks one instance of T. 
    T* newObject; 
    newObject = new T; 
    object = *newObject; 
} 

modèles ont généralement besoin de la mise en œuvre entière dans les fichiers d'en-tête, mais si vous êtes bien avec des types limités qui sont accepté, vous pouvez instancier explicitement les classes et ensuite vous pouvez avoir l'implémentation dans le fichier source:

Dans le fichier d'en-tête (n'importe où après le cours est définie):

extern template class Object<rectangleBase>; 
extern template class Object<circleBase>; 

Dans le fichier source (partout après les méthodes sont définies):

template class Object<rectangleBase>; 
template class Object<circleBase>; 

tout autre type que rectangleBase ou circleBase ne fonctionnera pas avec cette configuration.

Answer 3

Je ne sais pas quel est votre problème. Vous devez simplement implémenter vos fonctions, instancier le modèle et utiliser vos objets.

J'ai essayé, ça, ça fonctionne. S'il vous plaît, jetez un oeil: http://ideone.com/717044

#include <stdio.h> 

struct rectangleBase 
{ 
    int width, height; 
    int posX, posY; 
}; 

struct circleBase 
{ 
    int radius; 
    int posX, posY; 
}; 

template<typename T> 
class Object { 
public: 

    Object() { } 
    ~Object() { } 

    void movePos(int x, int y) 
    { 
     object.posX += x; 
     object.posY += y; 
    } 

    void setPos(int x, int y) 
    { 
     object.posX = x; 
     object.posY = y; 
    } 

    T& returnObject() { return object; } 

private: 
    T object; 
}; 

int main(int argc, char ** argv) 
{ 
    Object<rectangleBase> a; 
    Object<circleBase> b; 
    b.setPos(1,2); 
    printf("px: %d", b.returnObject().posX); 
} 

Si vous êtes intéressé nombre d'instances du compilateur de fonction susciteraient (ex: le code de vos fonctions est énorme), le compilateur le plus probable va générer autant de cas de code similaire à de nombreuses instanciations différentes. L'optimiseur peut en réduire certains. Mais si l'optimiseur le fait ou non, c'est difficile à dire.

L'approche lorsque vous utilisez des champs, des méthodes, des énumérations, etc. des types de paramètres du corps du modèle est appelée directement en utilisant des types dépendants. Oui, cette approche rend difficile ou impossible l'instanciation de votre modèle avec des types qui n'ont pas ce champ ou cette fonction membre. Néanmoins, ce modèle est largement utilisé.