関数テンプレートを部分的に特殊化できないのはなぜですか?


89

言語仕様が関数テンプレートの部分的な特殊化を禁止していることを私は知っています。

なぜそれが禁止されているのか、その理由を知りたいのですが?それらは役に立ちませんか?

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!

のためにtemplate<typename T, typename U> void f(T t, U u) {}template<> void f(int t, char u) {}許可されています。
ダッシュ2016

10
「どうすれば同じような目標を達成できるか」ではなく、「この行動の背後にある理由は何か」という質問に対して、人々が回避策を提供し続けるのは興味深いことです...私自身はこの選択の理由を知りませんが、委員会には、関数テンプレートの部分的な特殊化を禁止する理由があったに違いありません。これまでのところ、「最も近い」説明は、Georgyによって投稿されたリンクであり、オーバーロードが存在する場合の関数テンプレートの部分的な特殊化の潜在的な「リスク」のみを指摘しています。しかし、私はそれは私がもっとこの..にあると仮定して、この機能を禁止する理由はないと思う
bartgol

回答:


59

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
}

n3225の標準はありますか?クイック検索を行いましたが、見つかりませんでした:/
Matthieu M.

1
ああごめんなさい...言葉が欠けていた。ドキュメントはありますが、特定の段落が見つかりませんでした。あなたの編集を与えられたとしても、それは単にそこにないからだと思います:)
Matthieu M.

3
これはC ++ 0xでは変更されていません。私もその有用性を疑っています。テンプレートはいつでもオーバーロードして、半順序を利用できます。
Johannes Schaub-litb 2011

1
最新の更新:8年後のC ++ 17でも変更されておらず、C ++ 20にも入っていないようです。しかし、理由はわかりません...
アコンカグア

これは、この概念の最も包括的な実装であると私は信じています
ビクター

19

まあ、あなたは本当に部分的な関数/メソッドの特殊化を行うことはできませんが、オーバーロードを行うことはできます。

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

それは方法ですが、それがあなたを満足させるかどうかはわかりません。


2
うわー、私の心はテンプレートでいっぱいだったので、私は本当に簡単なことがどれほど簡単であるかを忘れました:)
Johannes

2
残念ながら、関数を部分的に特殊化した後で可変個引数を渡したい場合はそうではありません。:(
GwangmuLee19年

可変個引数テンプレートを渡すことの意味がわからないので、部分的な特殊化とどのように違うのか知りたいです。詳細を教えてください。
beginpluses

すべての積分型と浮動小数点型に対して2つの関数だけが必要な場合はどうなりますか?
DmitriyDokshin20年

15

一般に、オーバーロードの問題があるため、関数テンプレートを特殊化することはお勧めしません。これがC / C ++ユーザージャーナルからの良い記事です:http//www.gotw.ca/publications/mill17.htm

そしてそれはあなたの質問に対する正直な答えを含んでいます:

一つには、それらを部分的に専門化することはできません-言語があなたができないと言っているという理由だけで。


3
この記事は、一度言及されていることを除けば、部分的な特殊化に関するものではありません。
Euri Pinhollow 2017年

11

クラスを部分的に特殊化できるため、ファンクターを使用できます。

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

1
次に、単一の関数テンプレートを使用して呼び出しを行い、醜い()()構文を取り除くことができます。
tmr232 2016
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.