C ++関数テンプレートの部分的な特殊化？

以下のコードはクラスの部分的な特殊化であることを私は知っています：

template <typename T1, typename T2> 
class MyClass { 
  … 
}; 


// partial specialization: both template parameters have same type 
template <typename T> 
class MyClass<T,T> { 
  … 
}; 

また、C ++では関数テンプレートの部分的な特殊化が許可されていないことも知っています（完全のみが許可されています）。しかし、私のコードは、関数テンプレートを1つ/同じ型の引数に部分的に特化したことを意味しますか？Microsoft Visual Studio 2010 Expressで動作するためです！いいえの場合、部分特殊化の概念について説明していただけますか？

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

template <typename T1, typename T2> 
inline T1 max (T1 const& a, T2 const& b) 
{ 
    return a < b ? b : a; 
} 

template <typename T> 
inline T const& max (T const& a, T const& b)
{
    return 10;
}


int main ()
{
    cout << max(4,4.2) << endl;
    cout << max(5,5) << endl;
    int z;
    cin>>z;
}

関数の部分的な特殊化は、標準ではまだ許可されていません。この例では、実際にはオーバーロードしており、max<T1,T2>関数を特殊化していない。
その構文は見ている必要があり、ややそれが許されていた、以下のように：

// Partial specialization is not allowed by the spec, though!
template <typename T> 
inline T const& max<T,T> (T const& a, T const& b)
{                  ^^^^^ <--- [supposed] specializing here
  return 10;
}

関数テンプレートの場合、コンパイラ拡張を除いて、C ++標準では完全な特殊化のみが許可されています。

他の回答が指摘しているように、部分的な特殊化は許可されていないため、以下のように、を使用std::is_sameして回避できstd::enable_ifます。

template <typename T, class F>
inline typename std::enable_if<std::is_same<T, int>::value, void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with ints! " << f << std::endl;
}

template <typename T, class F>
inline typename std::enable_if<std::is_same<T, float>::value, void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with floats! " << f << std::endl;
}

int main(int argc, char *argv[]) {
    typed_foo<int>("works");
    typed_foo<float>(2);
}

出力：

$ ./a.out 
>>> messing with ints! works
>>> messing with floats! 2

編集：残っている他のすべてのケースを処理できるようにする必要がある場合は、すでに処理されたケースが一致してはならないことを示す定義を追加できます。そうしないと、あいまいな定義に陥ってしまいます。定義は次のようになります。

template <typename T, class F>
inline typename std::enable_if<(not std::is_same<T, int>::value)
    and (not std::is_same<T, float>::value), void>::type
typed_foo(const F& f) {
    std::cout << ">>> messing with unknown stuff! " << f << std::endl;
}

int main(int argc, char *argv[]) {
    typed_foo<int>("works");
    typed_foo<float>(2);
    typed_foo<std::string>("either");
}

生成するもの：

$ ./a.out 
>>> messing with ints! works
>>> messing with floats! 2
>>> messing with unknown stuff! either

このすべてのケースは少し退屈に見えますが、コンパイラにすでに行ったことをすべて伝える必要があるため、最大5つまたはそれ以上の特殊化を処理することは非常に実行可能です。

専門とは何ですか？

テンプレートを本当に理解したい場合は、関数型言語を確認する必要があります。C ++のテンプレートの世界は、それ自体が純粋に関数型のサブ言語です。

関数型言語では、選択はパターンマッチングを使用して行われます。

-- An instance of Maybe is either nothing (None) or something (Just a)
-- where a is any type
data Maybe a = None | Just a

-- declare function isJust, which takes a Maybe
-- and checks whether it's None or Just
isJust :: Maybe a -> Bool

-- definition: two cases (_ is a wildcard)
isJust None = False
isJust Just _ = True

ご覧のとおり、の定義をオーバーロードしますisJust。

そうですね、C ++クラステンプレートはまったく同じように機能します。パラメータの数と性質を示すメイン宣言を提供します。これは単なる宣言にすることも、定義（選択）として機能することもできます。その後、（必要に応じて）パターンの特殊化を提供し、クラスの別の（そうでない場合はばかげた）バージョンを関連付けることができます。 。

テンプレート関数の場合、特殊化はやや厄介です。オーバーロードの解決と多少競合します。そのため、特殊化は非特殊化バージョンに関連し、過負荷の解決中に特殊化は考慮されないことが決定されました。したがって、適切な関数を選択するためのアルゴリズムは次のようになります。

1. 通常の関数と特殊化されていないテンプレートの間で過負荷の解決を実行します
2. 特殊化されていないテンプレートが選択されている場合は、より適切な特殊化が存在するかどうかを確認します

（詳細な処理については、GotW＃49を参照してください）

そのため、関数のテンプレートの特殊化は、（文字通り）第2ゾーンの市民です。私に関する限り、それらがない方が良いでしょう。代わりにオーバーロードを使用してテンプレートの特殊化の使用を解決できないケースはまだ発生していません。

これはテンプレートの特殊化ですか？

いいえ、それは単に過負荷であり、これは問題ありません。実際、オーバーロードは通常、期待どおりに機能しますが、特殊化は驚くべきことです（リンクしたGotWの記事を思い出してください）。

非クラス、非変数の部分特殊化は許可されていませんが、次のように述べています。

コンピュータサイエンスのすべての問題は、別のレベルの間接参照によって解決できます。-デビッドウィーラー

関数呼び出しを転送するクラスを追加すると、これを解決できます。次に例を示します。

template <class Tag, class R, class... Ts>
struct enable_fun_partial_spec;

struct fun_tag {};

template <class R, class... Ts>
constexpr R fun(Ts&&... ts) {
  return enable_fun_partial_spec<fun_tag, R, Ts...>::call(
      std::forward<Ts>(ts)...);
}

template <class R, class... Ts>
struct enable_fun_partial_spec<fun_tag, R, Ts...> {
  constexpr static R call(Ts&&... ts) { return {0}; }
};

template <class R, class T>
struct enable_fun_partial_spec<fun_tag, R, T, T> {
  constexpr static R call(T, T) { return {1}; }
};

template <class R>
struct enable_fun_partial_spec<fun_tag, R, int, int> {
  constexpr static R call(int, int) { return {2}; }
};

template <class R>
struct enable_fun_partial_spec<fun_tag, R, int, char> {
  constexpr static R call(int, char) { return {3}; }
};

template <class R, class T2>
struct enable_fun_partial_spec<fun_tag, R, char, T2> {
  constexpr static R call(char, T2) { return {4}; }
};

static_assert(std::is_same_v<decltype(fun<int>(1, 1)), int>, "");
static_assert(fun<int>(1, 1) == 2, "");

static_assert(std::is_same_v<decltype(fun<char>(1, 1)), char>, "");
static_assert(fun<char>(1, 1) == 2, "");

static_assert(std::is_same_v<decltype(fun<long>(1L, 1L)), long>, "");
static_assert(fun<long>(1L, 1L) == 1, "");

static_assert(std::is_same_v<decltype(fun<double>(1L, 1L)), double>, "");
static_assert(fun<double>(1L, 1L) == 1, "");

static_assert(std::is_same_v<decltype(fun<int>(1u, 1)), int>, "");
static_assert(fun<int>(1u, 1) == 0, "");

static_assert(std::is_same_v<decltype(fun<char>(1, 'c')), char>, "");
static_assert(fun<char>(1, 'c') == 3, "");

static_assert(std::is_same_v<decltype(fun<unsigned>('c', 1)), unsigned>, "");
static_assert(fun<unsigned>('c', 1) == 4, "");

static_assert(std::is_same_v<decltype(fun<unsigned>(10.0, 1)), unsigned>, "");
static_assert(fun<unsigned>(10.0, 1) == 0, "");

static_assert(
    std::is_same_v<decltype(fun<double>(1, 2, 3, 'a', "bbb")), double>, "");
static_assert(fun<double>(1, 2, 3, 'a', "bbb") == 0, "");

static_assert(std::is_same_v<decltype(fun<unsigned>()), unsigned>, "");
static_assert(fun<unsigned>() == 0, "");

いいえ。たとえば、法的に専門化std::swapすることはできますが、独自のオーバーロードを法的に定義することはできません。つまりstd::swap、独自のカスタムクラステンプレートで作業を行うことはできません。

オーバーロードと部分的な特殊化は、場合によっては同じ効果をもたらす可能性がありますが、すべてではありません。

遅い答えですが、一部の遅い読者はそれが役に立つと思うかもしれません：時々、それが専門化できるように設計されたヘルパー関数も問題を解決することができます。

想像してみましょう、これが私たちが解決しようとしたことです：

template <typename R, typename X, typename Y>
void function(X x, Y y)
{
    R* r = new R(x);
    f(r, y); // another template function?
}

// for some reason, we NEED the specialization:
template <typename R, typename Y>
void function<R, int, Y>(int x, Y y) 
{
    // unfortunately, Wrapper has no constructor accepting int:
    Wrapper* w = new Wrapper();
    w->setValue(x);
    f(w, y);
}

OK、部分的なテンプレート関数の特殊化、それはできません...では、特殊化に必要な部分をヘルパー関数に「エクスポート」し、それを特殊化して使用しましょう。

template <typename R, typename T>
R* create(T t)
{
    return new R(t);
}
template <>
Wrapper* create<Wrapper, int>(int n) // fully specialized now -> legal...
{
    Wrapper* w = new Wrapper();
    w->setValue(n);
    return w;
}

template <typename R, typename X, typename Y>
void function(X x, Y y)
{
    R* r = create<R>(x);
    f(r, y); // another template function?
}

これは、代替案（専門分野ではなく通常のオーバーロード、ルーベンスによって提案された回避策、... –これらが悪い、または私の方が優れているということではなく、別の1つだけ）が非常に多くの共通コードを共有する場合に特に興味深い可能性があります。