quand est-il préférable d'utiliser le modèle C++?

Question

maintenant j'apprends C++, et maintenant je connais le concept de base de modèle, qui agissent comme un type générique, et j'ai trouvé presque tous les programmes C++ utilisés modèle, Donc, je veux vraiment savoir quand nous sommes supposés utiliser le modèle? Quelqu'un peut-il conclure votre expérience sur le modèle C++? Quand envisagez-vous d'utiliser le modèle?

Supplément: si nous avons défini cette fonction

template <class myType> 
myType GetMax (myType a, myType b) { 
return (a>b?a:b); 
} 

mais nous voulons passer pour la comparaison d'un objet (classe d'auto-défini), comment pouvons-nous mettre en œuvre?

Supplement2: dans la réponse ci-dessous, quelqu'un a écrit ce code exemple

template <class myType> 
const myType& GetMax (const myType& a, const myType& b) { 
    return (a<b?b:a); 
} 

template <class myType, class Compare> 
const myType& GetMax (const myType& a, const myType& b, Compare compare) { 
    return (compare(a,b)?b:a); 
} 

est-ce correct? peut-on simplement passer un nom de fonction en paramètre de la classe myType?

Answer 1

Re: complément. Si vous voulez passer une fonction de comparaison, vous pouvez fournir une autre surcharge:

template <class myType> 
const myType& GetMax (const myType& a, const myType& b) { 
    return (a<b?b:a); 
} 

template <class myType, class Compare> 
const myType& GetMax (const myType& a, const myType& b, Compare compare) { 
    return (compare(a,b)?b:a); 
} 

utilisation SAMLE: pour comparer des chaînes de style C:

bool c_strings_less(const char* a, const char* b) 
{ 
    return std::strcmp(a, b) < 0; //is a less than b 
} 

const char* greater = GetMax("hello", "world", c_strings_less); 

Voici comment fonctionne l'algorithme std :: max. (J'ai aussi fait quelques modifications, par exemple, il est habituel en C++ que les prédicats définissent une comparaison "inférieure à".)

Ou si vous avez demandé comment GetMax fonctionnerait pour des types arbitraires définis par l'utilisateur, ceux-ci doivent surcharger l'opérateur. > ou votre fonction entraînerait une erreur de compilation.

Answer 2

si vous ne connaissez pas le type de votre variable ou que vous voulez faire de même pour de nombreux types de variables, vous pouvez utiliser le modèle ...

si vous voulez ajouter 2 int, vous voulez obtenir un int pour le retour si vous voulez ajouter 2 lits doubles, vous voulez obtenir un double pour le retour

vous utilisez donc ce modèle pour ..

Answer 3

Fondamentalement quand vous voulez créer une classe générique qui peut gérer la solution pour plusieurs types de classes, sans avoir à avoir une classe parent pour toutes les classes que vous voulez supporter.

Vous pouvez juste donner à la classe avec laquelle vous voulez travailler avec (meilleur exemple serait un conteneur, qui peut stocker tout type que vous passez avec la création)

//----- the container 
template <class T> 
class Stack 
{ 
public: 
    T* stackPtr; 
} 

//----- example 
void main() 
{ 
    typedef Stack<float> FloatStack; 
    typedef Stack<int> IntStack; 
} 

Maintenant vous pouvez stocker floats et ints avec la même classe sans avoir à écrire une classe spécifique pour chaque type.

Answer 4

Réponse courte: si cela ne sert à rien: pas. S'il semble résoudre un problème (réutilisation de code sur différents types, ...), implémentez et déboguez d'abord sans les templates, puis ajoutez les paramètres du template. Avant STL/boost, ils étaient agréables à fabriquer des conteneurs.

Answer 5

Lorsque vous devez paramétrer un concept représenté par une classe.

Par exemple, si vous avez une classe qui représente un moyen de gérer un type d'objet

class MyThingManager 
{ 
    void add(MyThing& mything); 
    //... 
}; 

... vous avez besoin plus tard peut-être utiliser exactement le même comportement dans un nouveau type, mais la gestion d'un autre type. Ensuite, vous avez le choix d'utiliser le copier/coller/remplacer --Que conduirait l'ouverture de l'enfer sous vos pieds immediately-- ou faire de votre classe ont un type de gestion comme parametter:

template< class ThingType > 
class ThingManager 
    { 
     void add(ThingType& thing); 
     //... 
    }; 

De cette façon, vous ne dupliquer le code.

Une autre préoccupation est quand vous voulez un appel de fonction pour être compatible avec tous les paramètres qui ont le besoin sémantique:

template< class MyType > 
void addPi(MyType& value) 
{ 
    value += PI; 
} 

De cette façon, vous (encore) ne doivent pas dupliquer du code pour chaque type possibles parametres.

Ce n'est pas appelé "programmation générique" pour rien.

Ce sont des cas simples, mais des cas plus complexes existent, lorsque vous voulez faire de la méta-programmation. Si vous voulez y aller, s'il vous plaît lire au moins un livre avant d'écrire le code de l'enfer. Je recommande "Meta-Programming Template C++" pour cela et l'excellent livre "Modern C++ Design" pour l'utilisation de modèles plus avancés comme le modèle de politique et d'autres bien connus.

Answer 6

G'day,

réponse simple est quand vous voulez que le comportement reste le même indépendamment du type utilisé pour instancier la classe. Par conséquent, une pile d'ints se comportera de la même manière qu'une pile de flottants se comportera comme une pile d'objets MyClass.

Les classes d'héritage et de base sont utilisées lorsque vous souhaitez autoriser la spécialisation du comportement. Par exemple, vous avez une classe de base appelée Animal et une fonction membre appelée makeSound(). Vous n'avez aucune idée du son que fera chaque animal, donc vous faites de la fonction membre makeSound une fonction virtuelle. En fait, comme il n'y a pas de son par défaut pour tous les animaux, vous n'avez aucune idée de ce qu'il doit avoir comme comportement par défaut, donc vous déclareriez cette fonction membre comme une fonction virtuelle pure. Cela indique ensuite à toute personne faisant une instance d'une classe dérivée, par exemple une classe Lion, qu'elle doit fournir une implémentation de la fonction membre makeSound qui fournira un rugissement d'une certaine manière.

Edit: Je oublié d'ajouter que c'est l'un des articles dans l'excellent livre de Scott Meyers « efficace C++ » (sanitised Amazon link) que je recommande fortement.

HTH

acclamations,

Answer 7

Répondre à la deuxième question (par comparaison, mais nous voulons transmettre un objet (classe autodéfinie) comment pouvons-nous mettre en œuvre?)

Si vous voulez pour utiliser votre propre classe dans une fonction de modèle en utilisant l'opérateur >. Votre classe n'a besoin que de définir cet opérateur ou cette fonction.

La partie importante est que votre classe doit définir la même l'opérateur ou la fonction que le modèle utilise.

/Tobias

Answer 8

modèle fournit le chemin de paramètrer sur CONNU AU TEMPS quantités COMPILE.Notez qu'il peut être un type (std :: vecteur contiendra uniquement des entiers), mais ils peuvent aussi être des valeurs:

template <int N, typename T > class MyType 

est à la fois sur un sans canevas entier et un type, et MyType < 2, int> sera un type différent de MyType < 3, int>.

En outre, les modèles permettent la métaprogrammation de modèles: c'est-à-dire que le compilateur exécute un programme au moment de la compilation. Il y a un exemple fascinant d'Erwin Unruh pour le calcul des nombres premiers au moment de la compilation.

Regardez http://ubiety.uwaterloo.ca/~tveldhui/papers/priority.html pour un petit peu d'histoire.

Answer 9

Dans l'exemple fourni, tout est OK tant que operator > est défini pour le type de données dont vous comparez les instances.

Par exemple, si vous définissez la classe suivante:

class fraction 
{ 
private: 
    int _num, _den; 

public: 
    fraction(int num, int den) 
    { 
     if (den >= 0) 
     { 
      _num = num; 
      _den = den; 
     } 
     else 
     { 
      _num = -num; 
      _den = -den; 
     } 
    } 

    fraction(const fraction &f) 
    { 
     _num = f._num; 
     _den = f._den; 
    } 

    bool operator > (const fraction &f) const 
    { 
     return (_num * f._den) > (f._num * _den); 
    } 

    bool operator == (const fraction &f) const 
    { 
     return (_num * f._den) == (f._num * _den); 
    } 
}; 

Ensuite, vous pouvez utiliser votre fonction de modèle avec des instances de cette classe.

int main(int argc, char* argv[]) 
{ 
    fraction a(1,2); // 0.5 
    fraction b(3,4); // 0.75 
    assert(GetMax/*<fraction>*/(a,b) == a); 
    return 0; 
} 

Answer 10

Il est important de noter qu'il est parfaitement normal de ne pas écrire vos propres modèles. Si vous n'êtes pas sûr de savoir pourquoi vous pourriez en avoir besoin, alors vous n'en avez probablement pas besoin. Les modèles sont un outil très puissant, mais ils ne sont pas toujours la meilleure solution.

Sur n'importe quelle plate-forme de développement commune, la bibliothèque standard fournit une implémentation de haute qualité de nombreuses utilisations traditionnelles des modèles à l'ancienne. L'utilisation des classes et des fonctions de bibliothèque standard ne nécessite pas l'écriture de nouveaux modèles. Par exemple, il fournit std :: max(), qui est le même que votre exemple.