keine Instanz von funktionsvorlage entspricht der argument-Liste (drucken möchten, array)

Beim Versuch zu kompilieren dieser

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);

und verwenden Sie es wie diese

d_prettyPrintVector(dc, blockDim.x);

Ich bin immer

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

was ist falsch?

update: wenn Sie nicht mit der Funktion (nur instanziieren der Schablone), bekomme ich folgenden Fehler: kernels.cu:65: error: a cast to a type other than an integral or enumeration type cannot appear in a constant-expression Kernel.cu:65: Fehler: template-id 'd_prettyPrintVector<int <expression-Fehler> >" für "nichtig d_prettyPrintVector(int*, unsigned int)" nicht mit jedem template-Deklaration`
mögliche Duplikate von Übergeben const char* als template-argument
Danke, es ist das gleiche zugrunde liegende problem, aber die workarounds sind unterschiedlich. Außerdem sah ich, dass eine Frage als ich fragte, mine, aber ich wusste nicht, wie es zusammenhängt. Ich Wette, dass es Neulinge wie mich, wer wird davon profitieren ein weiteres Beispiel.

InformationsquelleAutor Leo | 2015-03-12

  1. 1

    Ich denke, Sie sind nicht klar, wie der Typ, derfloat, int usw., greifen Sie eine geeignete format-string.

    Können Sie re-design Ihrer Funktion so Aussehen:

     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.
 }

    Das wäre perfekt gültigen code, wenn Sie hatte eine Funktion Vorlage:

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

    hatte, die Spezialisierungen für die Typen, die Sie interessiert sind in. In anderen Worten, sollten die folgenden arbeiten:

     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 "; }

    Nun, die Sie verwenden können:

     int a[] = {1, 2};
 d_prettyPrintVector(a, 2);

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

    ohne jedes problem.

    Extra

    Können Sie erweitern, dass die Idee, eine lambda-Funktion als argument zu d_prettyPrintVector. Die lambda-Funktion zurückgeben kann eine benutzerdefinierte Formatzeichenfolge, die besser geeignet für einen single-use-case.

    Überlastung d_prettyPrintVector. Stellen ein, die ein lamba-Funktion als argument.

     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]);
}

    Sie können sogar implementieren der ersten Funktion mit der neuen Funktion, so dass Sie nicht haben, wiederholen Sie die details, wie die Elemente ausgegeben werden.

    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>();});
}

    Nun, zusätzlich zu den bisherigen Aufrufe von print a und b können Sie nun verwenden:

       //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 ";});

    InformationsquelleAutor R Sahu

Schreibe einen Kommentar