Pouvez-vous créer une fonction générique C ++?

Est-il possible de créer un générique de fonction C++foo?

foo(Object bar, Object fred)
{
    //code
}

dans lequel que si les deux objets sont reconnus, ils sont comparés et une valeur de comparaison est retourné sinon une autre valeur est retourné pour indiquer une comparaison n'était pas possible?

Que je pose dans le cas de genericizing un tri de classe, auquel cas vous pouvez utiliser cette méthode, et lorsque vous dérivez les nouveaux objets que vous souhaitez trier, vous ajoutez à cela foo fonction, une méthode sur laquelle trier le nouveau type d'Objet.

source d'informationauteur SGE

c++generics object oop sorting

18

Je pense que vous êtes dans le besoin de Modèles!

Vous pouvez écrire une fonction de modèle, puis d'écrire une spécialisation pour les types de faire quelque chose de précis, si le besoin en est.

À l'aide de modèles, de définir les deux versions de la fonction, l'une où les paramètres sont du même type et un endroit où ils peuvent être différents:

#include <string>
#include <iostream>
using namespace std;

template<typename Type>
void func(Type, Type)
{
    cout << "same" << endl;
}

template<typename TypeA, typename TypeO>
void func(TypeA, TypeO)
{
    cout << "different" << endl;
}

int main()
{
    func(5, 3);                     //same
    func(5, 3.0);                   //different
    func(string("hello"), "hello"); //different
    func(5.0, 3.0);                 //same
    return 0;
}

Sortie:

same
different
different
same

template<class Type1, class Type2>
void foo(Type1 t1, Type2 t2)
{
   //put code here for function
}

appel

foo<std::string, int> ("hello", 10);

La plupart vous avez probablement besoin d'utiliser des modèles que d'autres personnes suggèrent:

template <class T>
return_type func(T const& l, T const& r)
{
   ...
}

Parce que, normalement, vous voulez compilation échec lors de l'opération mise en œuvre par une fonction générique n'a pas de sens pour certains types, de sorte que vous utilisez soit conditionnelle à la définition (dans l'exemple ci-dessous is_arithmetic):

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_arithmetic.hpp>

template <class T>
typename boost::enable_if<boost::is_arithmetic<T>, return_type>::type
func(T const& l, T const& r)
{
    ...
}

ou statique affirmation dans le code afin de donner le même résultat:

#include <boost/type_traits/is_arithmetic.hpp>

template <class T>
return_type func(T const& l, T const& r)
{
    static_assert(boost::is_arithmetic<T>::type::value, "incompatible types");
    ...
}

1

Je vais m'en tenir à mon cou et dire que vous n'avez pas besoin Modèles pour ce faire. Je ne dis pas ne pas les utiliser, mais juste que selon exactement ce que vous êtes désireux de le faire, il existe des alternatives.

Ce qu'il sons comme vous voulez, c'est la capacité à comparer les deux des objets génériques à condition qu'ils adhèrent à un ensemble commun de règles de base. Vous pouvez effectivement mettre en œuvre ce à l'aide de l'héritage traditionnel, ou à l'aide de modèles. Le choix de qui vous voulez dépend de la façon dont flexible vous le souhaitez et si vous voulez un peu de la prise de décisions au moment de l'exécution ou de la compilation. Si ce dernier - c'est à dire que vous souhaitez récupérer sur le casting des erreurs, etc., - puis aller pour les modèles.

De toute façon, vos objets seront, soit à adhérer à certaines de base groundrules de la façon dont vous les comparer et de préférence encapsuler que - de cette façon, votre comparitor serait générique. ou vous devriez écrire différents comparitors pour chaque objet de la comparaison. Bien qu'il sonne comme le dernier est ce que vous voulez, méfiez-vous de laisser trop de votre implémentation de la classe de lessivage dans le comparitor fonction et ainsi briser l'encapsulation.

À partir de ma propre expérience, aller tout droit vers le modèle de l'approche peut parfois entraîner beaucoup de ballonnement, foiré code qui est dur à lire, à déboguer et à entretenir. Jetez un coup d'oeil dur à concevoir et ce que vous avez réellement besoin en premier.
0

OP semble vouloir savoir si les 2 objets sont comparables ou non. Vous pouvez utiliser un modèle de spécialisation pour réaliser ceci (note: ce ne compile pas sur la VC 10, mais n'sur g++ 4.7). La seule nuance, c'est que vous voulez cette fonction pour

ils sont comparés et une valeur de comparaison est retourné sinon une autre valeur est retourné pour indiquer une comparaison n'était pas possible

Mais vous avez besoin de définir une sorte de structure pour signifier que la comparaison n'était pas possible; l'aide d'un nombre magique "-500' ou autre n'est pas un bon style. Alternativement, vous pouvez jeter une erreur, et lui permettre d'être attrapé un manipulés.
```
struct NoCompare{};

template <typename U1, typename U2>
static auto compare2(const U1 & u1, const U2 & u2) -> decltype(u1 == u2)
{ 
    cout << "Comparable" << endl;
    return u1 == u2;
}

static int compare2(...) 
{ 
    //Comparison not supported - return whatever value you want. (change the return type as appropriate)
    cout << "Not comparable" << endl;
    return -500;
}

int main()
{
    int a = 5, b = 3, c = 3;
    NoCompare dns;
    cout << compare2(a, b) << endl;
    cout << compare2(dns, b) << endl;
    cout << compare2(c, b) << endl;

    return 0;
}
```
De sortie:
C:\MinGW\MinGW>
Comparable
0
Pas comparable
-500
Comparable
1
0

Il semble que vous faites référence à la Common Lisp /CLOS-style de fonctions génériques qui font de multiples dynamiques de l'expédition. C++ ne prend seul la distribution dynamique avec des méthodes, mais seulement statique unique de répartition des fonctions. Donc la réponse est non. C++ ne prend pas en charge le moment. Certaines propositions ont été faites tout au long des années à l'ajouter dans la langue, mais qui n'est pas encore arrivé.

Vous devez vous connecter pour publier un commentaire.