Warum kann Funktionsvorlage nicht teilweise spezialisiert werden?

Ich die Sprache kennen-Spezifikation verbietet teilweise Spezialisierung der Funktion Vorlage.

Ich würde gerne wissen, die Gründe, warum es verboten wird? Sind Sie nicht nützlich?

template<typename T, typename U> void f() {}   //allowed!
template<> void f<int, char>()            {}   //allowed!
template<typename T> void f<char, T>()    {}   //not allowed!
template<typename T> void f<T, int>()     {}   //not allowed!

InformationsquelleAutor der Frage Nawaz | 2011-02-24

  1. 48

    AFAIK hat sich das verändert in C++0x.

    Ich denke, es war nur ein versehen (wenn man bedenkt, dass Sie immer die partielle Spezialisierung Effekt mit Ausführlicher code, indem Sie die Funktion als static member einer Klasse).

    Vielleicht schauen Sie relevante DR (Mängelanzeige), wenn es einen gibt.

    BEARBEITEN: wenn Sie dieses, finde ich, die anderen haben auch geglaubt, dass, aber niemand ist in der Lage zu finden, eine solche Unterstützung in dem Norm-Entwurf. Diese SO-thread scheint zu zeigen, dass teilweise Spezialisierung von Funktions-templates wird nicht unterstützt in C++0x.

    EDIT 2: nur ein Beispiel, was ich damit meine "Platzierung der Funktion als static Mitglied einer Klasse":

    #include <iostream>
using namespace std;

//template<typename T, typename U> void f() {}   //allowed!
//template<> void f<int, char>()            {}   //allowed!
//template<typename T> void f<char, T>()    {}   //not allowed!
//template<typename T> void f<T, int>()     {}   //not allowed!

void say( char const s[] ) { std::cout << s << std::endl; }

namespace detail {
    template< class T, class U >
    struct F {
        static void impl() { say( "1. primary template" ); }
    };

    template<>
    struct F<int, char> {
        static void impl() { say( "2. <int, char> explicit specialization" ); }
    };

    template< class T >
    struct F< char, T > {
        static void impl() { say( "3. <char, T> partial specialization" ); }
    };

    template< class T >
    struct F< T, int > {
        static void impl() { say( "4. <T, int> partial specialization" ); }
    };
}  //namespace detail

template< class T, class U >
void f() { detail::F<T, U>::impl(); }    

int main() {
    f<char const*, double>();       //1
    f<int, char>();                 //2
    f<char, double>();              //3
    f<double, int>();               //4
}

    InformationsquelleAutor der Antwort Cheers and hth. - Alf

  2. 13

    Im Allgemeinen ist es nicht empfohlen, sich zu spezialisieren-Funktion-Vorlagen an alle, wegen der Probleme mit überlastung. Hier ist ein guter Artikel aus der C/C++ Users Journal: http://www.gotw.ca/publications/mill17.htm

    Und enthält eine ehrliche Antwort auf Ihre Frage:

    Für eine Sache, Sie kann nicht teilweise spezialisieren Sie-ziemlich viel, nur weil die Sprache, sagt Sie nicht.

    InformationsquelleAutor der Antwort Georgy Pashkov

  3. 8

    Gut, kann man wirklich nicht tun, partielle Funktion/Methode Spezialisierung jedoch, die Sie tun können, zu überladen.

    template <typename T, typename U>
T fun(U pObj){...}

//acts like partial specialization <T, int> AFAIK 
//(based on Modern C++ Design by Alexandrescu)
template <typename T>
T fun(int pObj){...}

    Es ist der Weg, aber ich weiß nicht, ob es Sie zufrieden zu stellen.

    InformationsquelleAutor der Antwort Michal W

  4. 7

    Da kann man teilweise spezialisieren Klassen, die Sie verwenden können, Funktor:

    #include <iostream>

template < typename dtype , int k > struct fun
{
 int operator()()
 {
  return k ;
 }
} ;

template < typename dtype > struct fun < dtype , 0 >
{
 int operator()()
 {
  return 42 ;
 }
} ;

int main ( int argc , char * argv[] )
{
 std::cout << fun<float,5>()() << std::endl ;
 std::cout << fun<float,0>()() << std::endl ;
}

    InformationsquelleAutor der Antwort Kay F. Jahnke

Schreibe einen Kommentar