Al intentar compilar este

template<typename type,const char* format>__device__ void d_prettyPrintVector(type* v, const unsigned int size)
{
    printf("\n ");
    for(int i=0; i<size; i++)
            printf(format, v[i]);
}
template<> void d_prettyPrintVector<float, "%4.1f ">(float*, const    unsigned int);
template<> void d_prettyPrintVector<int,   "%2d "  >(int*,   const unsigned int);
template<> void d_prettyPrintVector<char,  "%2d "  >(char*,  const unsigned int);
template<> void d_prettyPrintVector<bool,  "%d"    >(bool*,  const unsigned int);

y el uso de esta

d_prettyPrintVector(dc, blockDim.x);

Estoy recibiendo

kernels.cu(104): error: no instance of function template "d_prettyPrintVector" matches the argument list
        argument types are: (int *, const unsigned int)

lo que está mal?

  • actualización: cuando no se utiliza la función (sólo a instancias de la plantilla), me da los siguientes errores: kernels.cu:65: error: a cast to a type other than an integral or enumeration type cannot appear in a constant-expression núcleos.cu:65: error: plantilla-id ‘d_prettyPrintVector<int a, <error de expresión> >’ para ‘void d_prettyPrintVector(int*, unsigned int)’ no coincide con ninguna declaración de la plantilla`
  • posibles duplicados de Pasando const char* como argumento de plantilla
  • Gracias, es el mismo problema de fondo, pero las soluciones son diferentes. Por otra parte, vi que pregunta cuando me pidió el mío, pero yo no veo cómo se relacionan. Estoy apostando a que hay novatos como yo, que se beneficiarán de otro ejemplo.
InformationsquelleAutor Leo | 2015-03-12

1 Comentario

  1. 1

    Creo que no tienes claro cómo utilizar el tipo, float, int, etc., para agarrar una adecuada cadena de formato.

    Puede re-diseño de su función a buscar algo así como:

     template <typename type>
     void d_prettyPrintVector(type* v, const unsigned int size)
     {
        printf("\n");
        for(int i=0; i<size; i++)
                printf(getFormatString<type>(), v[i]);
                       //^^^ Get an format string appropriate for the type.
     }

    Que sería perfectamente válido código si usted tenía una plantilla de función:

     template <typename type> char const* getFormatString();

    que había especializaciones para los tipos que usted está interesado en. En otras palabras, los siguientes trabajos:

     template <typename type> char const* getFormatString();
    
     template <typename type>
     void d_prettyPrintVector(type* v, const unsigned int size)
     {
        printf("\n");
        for(int i=0; i<size; i++)
                printf(getFormatString<type>(), v[i]);
                       //^^^ Get an format string appropriate for the type.
     }
    
     template <> char const* getFormatString<float>() { return "%4.1f "; }
     template <> char const* getFormatString<int>()   { return "%2d "; }
     template <> char const* getFormatString<char>()  { return "%2d "; }
     template <> char const* getFormatString<bool>()  { return "%1d "; }

    Ahora, usted puede utilizar:

     int a[] = {1, 2};
     d_prettyPrintVector(a, 2);
    
     float b[] = {1.1f, 2.2f};
     d_prettyPrintVector(b, 2);

    sin ningún problema.

    Extra

    Puedes ampliar la idea de proporcionar una función lambda como un argumento a d_prettyPrintVector. La función lambda puede devolver una cadena de formato personalizado que es más apropiado para un único caso de uso.

    Sobrecarga d_prettyPrintVector. Proporcionar uno que puede tomar un lamba función como argumento.

     template <typename type, typename Format>
     void d_prettyPrintVector(type* v, const unsigned int size, Format format)
     {
         printf("\n");
         for(int i=0; i<size; i++)
                 printf(format(), v[i]);
    }

    Incluso se puede implementar la función inicial utilizando la nueva función de modo que usted no tiene que repetir los detalles de cómo los elementos se imprimen.

    template <typename type> char const* getFormatString();
    
    template <typename type>
    void d_prettyPrintVector(type* v, const unsigned int size)
    {
       d_prettyPrintVector(v, size, [](){return getFormatString<type>();});
    }

    Ahora, en adición a las anteriores convocatorias para imprimir a y b, ahora se puede utilizar:

       //Define the format on the fly, using a lambda function.
       d_prettyPrintVector(a, 2, []() -> char const* {return "%4d ";});
    
       //Define the format on the fly, using a lambda function.
       d_prettyPrintVector(b, 2, []() -> char const* {return "%.6f ";});

Dejar respuesta

Please enter your comment!
Please enter your name here