Estoy teniendo un puntero a la común método estático

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

señalando el método estático

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

De inicialización:

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

Me gustaría convertir este puntero a la plantilla estática puntero a función:

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

donde:

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

Pero existe el siguiente error de compilación:

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

Gracias por tu ayuda…

InformationsquelleAutor Ian | 2011-01-01

4 Comentarios

  1. 15

    En el segundo caso, getA no es una función sino una función plantilla, y usted no puede tener un puntero a la función de la plantilla.

    Lo que usted puede hacer es tener pfunction punto a un particular getA instancia (es decir: para 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>;

    Pero no creo que hay una manera de conseguir pfunction a punto de cualquier ejemplo posible de getA.

  2. 12

    plantilla es un plantilla 🙂 no es un tipo concreto, y no puede ser utilizado como un miembro. por ejemplo, usted puede definir la siguiente clase:

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

    porque template <class T> std::vector<T> member; es algo que potencialmente puede ser especializado para muchos tipos diferentes. usted puede hacer algo como esto:

    template <class T>
    struct A
    {
     static T (*pfunction)();
    };
    
    struct B
    {
     template <class T>
     static T getT();
    };
    
    int (*A<int>::pfunction)() = &B::getT<int>;

    aquí A<int> está especializada en la plantilla, lo que se ha especializado miembro

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

    Plantilla de función de puntero es ilegal en C++. Estar dentro de una clase, o simplemente fuera de una clase. Usted no puede escribir esto (no incluso fuera de la clase):

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

    Ver este ejemplo : http://www.ideone.com/smh73

    El Estándar de C++ dice en $14/1,

    Una plantilla define una familia de clases
    o funciones.

    Por favor note que NO dice «Una plantilla define una familia de clases, funciones o punteros a función«. Así que lo que estamos tratando de hacer es, la definición de «una familia de punteros a función» con la plantilla, que no está permitido.

    Genérico Functors de Loki biblioteca sería una solución elegante para el tipo de problema que usted está teniendo. 🙂

  4. 2

    Una cosa que puedes hacer es tener una copia de la plantilla de función miembro en el archivo cpp y punto para que decir

    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 

    sin embargo, usted puede apuntar a

    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! 

Dejar respuesta

Please enter your comment!
Please enter your name here