C++, la fonction pointeur vers le modèle de pointeur de fonction

Je vais avoir un pointeur vers la commune de la méthode statique

class MyClass
{
  private:
    static double ( *pfunction ) ( const Object *, const Object *);
    ...
};

pointant à la méthode statique

 class SomeClass
 {
  public:
    static double getA ( const Object *o1, const Object *o2);
    ...
 };

Initialisation:

double ( *MyClass::pfunction ) ( const Object *o1, const Object *o2 )  = &SomeClass::getA;

Je voudrais le convertir de ce pointeur pour le modèle statique de pointeur de fonction:

template <class T>
static T ( *pfunction ) ( const Object <T> *, const Object <T> *); //Compile error

où:

 class SomeClass
 {
  public:
    template <class T>
    static double getA ( const Object <T> *o1, const Object <T> *o2);
    ...
 };

Mais il y a l'erreur de compilation suivante: 

error: template declaration of : T (* pfunction )(const Object <T> *o1, const Object <T> *o2)

Merci pour votre aide...

InformationsquelleAutor Ian | 2011-01-01
  1. 15

    Dans le second cas, getA n'est pas une fonction mais une fonction modèle, et vous ne pouvez pas avoir un pointeur vers la fonction de modèle.

    Ce que vous pouvez faire est d'avoir pfunction point à un particulier getA instance (ie: pour T = int) :

    class MyClass
{
    static double (*pfunction)(const Object<int> *, const Object<int> *);
};

double (*MyClass::pfunction)(const Object<int> *o1, const Object<int> *o2)  = &SomeClass::getA<int>;

    Mais je ne pense pas qu'il y est un moyen d'obtenir pfunction faire le point sur tout exemple possible de getA.

    InformationsquelleAutor icecrime
  2. 12

    modèle est un modèle 🙂 ce n'est pas un type concret et ne peut pas être utilisé en tant que membre. par exemple, vous ne pouvez pas définir de classe suivant:

    class A
{
    template <class T> std::vector<T> member;
}

    parce que template <class T> std::vector<T> member; est quelque chose qui potentiellement peuvent être spécialisés pour de nombreux types différents. vous pouvez faire quelque chose comme ceci:

    template <class T>
struct A
{
 static T (*pfunction)();
};

struct B
{
 template <class T>
 static T getT();
};

int (*A<int>::pfunction)() = &B::getT<int>;

    ici A<int> est spécialisé pour un modèle, et s'est spécialisé membre

    InformationsquelleAutor Andriy Tylychko
  3. 8
    template <class T>
static T ( *pfunction ) ( const Object <T> *, const Object <T> *);

    Modèle de pointeur de fonction est illégal en C++. Être à l'intérieur d'une classe, ou tout simplement à l'extérieur d'une classe. Vous ne pouvez pas écrire (pas même de l'extérieur d'une classe):

    template <class X>
void (*PtrToFunction) (X);

    Voir cet exemple : http://www.ideone.com/smh73

    La Norme C++ est dit dans $14/1,

    Un modèle définit une famille de classes
    ou fonctions.

    Veuillez noter qu'il ne dit PAS "Un modèle définit une famille de classes, fonctions ou des pointeurs de fonction". Donc, ce que vous essayez de faire, c'est que la définition de "une famille de pointeurs de fonction" à l'aide de modèle, qui n'est pas autorisé.

    Générique Foncteurs de Loki bibliothèque serait une solution élégante pour le genre de problème que vous rencontrez. 🙂

    InformationsquelleAutor Nawaz
  4. 2

    Une chose que vous pouvez faire est d'avoir une copie du modèle de la fonction de membre dans le fichier cpp et à point à qui c'est à dire 

    template <+typename ElementType>
int PQueueHeap<ElementType>::compareFunction(ElementType First,ElementType Second)
{   
    if (First>Second) return 1; else if (First==Second) return 0; else return -1;
}

//you cannot point to above

    cependant, vous pouvez pointer vers 

    template <+typename ElementType>

int compareFunction(ElementType First,ElementType Second)
{

if (First>Second) return 1; else if (First==Second) return 0; else return -1;
} //No error and it works!
    InformationsquelleAutor Adel