為什么功能模板不能部分專用？

Question

我知道語言規范禁止功能模板的部分特化。

我想知道為什么禁止它的理由？ 它們沒用嗎？

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!

Answer 1

在C ++ 0x中更改的AFAIK。

我想這只是一個疏忽（考慮到你可以通過將函數作為類的static成員來獲得更詳細的代碼來獲得部分特化效果）。

您可以查找相關的DR（缺陷報告）（如果有）。

編輯 ：檢查這一點，我發現其他人也相信，但沒有人能夠在草案標准中找到任何這樣的支持。 這個SO線程似乎表明在C ++ 0x中不支持函數模板的部分特化 。

編輯2 ：只是“將函數作為類的static成員放置”的意思的一個例子：

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

Answer 2

一般情況下，由於存在重載問題，因此不建議專門設計功能模板。 以下是C / C ++用戶期刊的一篇好文章： http ： //www.gotw.ca/publications/mill17.htm

它包含對您問題的誠實回答：

首先，你不能對它們進行部分專業化 - 幾乎只是因為語言說你做不到。

Answer 3

好吧，你真的不能做部分功能/方法專業化，但你可以做重載。

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

這是方式，但我不知道它是否滿足你。

Answer 4

由於您可以部分地專門化類，因此可以使用仿函數：

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