Warum kann die Funktionsvorlage nicht teilweise spezialisiert werden?

Ich weiß, dass die Sprachspezifikation eine teilweise Spezialisierung der Funktionsvorlage verbietet .

Ich würde gerne wissen, warum es das verbietet. 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!

AFAIK, das in C ++ 0x geändert wurde.

Ich denke, es war nur ein Versehen (wenn man bedenkt, dass man den partiellen Spezialisierungseffekt immer mit ausführlicherem Code erzielen kann, indem man die Funktion als staticMitglied einer Klasse platziert).

Sie können den entsprechenden DR (Fehlerbericht) nachschlagen, falls vorhanden.

EDIT : Wenn ich das überprüfe, finde ich, dass andere das auch geglaubt haben, aber niemand kann eine solche Unterstützung im Standardentwurf finden. Dieser SO-Thread scheint darauf hinzudeuten, dass eine teilweise Spezialisierung von Funktionsvorlagen in C ++ 0x nicht unterstützt wird .

EDIT 2 : nur ein Beispiel dafür, was ich unter "Platzieren der Funktion als staticMitglied einer Klasse" verstanden habe:

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

Nun, Sie können wirklich keine Teilfunktions- / Methodenspezialisierung durchführen, aber Sie können eine Überladung durchführen.

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 dich zufriedenstellt.

Im Allgemeinen wird aufgrund von Problemen mit der Überlastung nicht empfohlen, Funktionsvorlagen überhaupt zu spezialisieren. Hier ist ein guter Artikel aus dem C / C ++ Users Journal: http://www.gotw.ca/publications/mill17.htm

Und es enthält eine ehrliche Antwort auf Ihre Frage:

Zum einen kann man sie nicht teilweise spezialisieren - so ziemlich nur, weil die Sprache sagt, dass man es nicht kann.

Da Sie Klassen teilweise spezialisieren können, können Sie einen Funktor verwenden:

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