Variadicテンプレートと関数のポインタ：どのコンパイラが正しいのですか？

Question

_{私はより良いタイトルを見つけることができませんでしたが、あなたが正しい考えを持っている場合は、それを自由に変更してください。そのままで、それはよりも優れています。とにかくGCC vs clangです。}

---

私はこのコードで間違っているかを把握しようとしている：

template <typename... T> 
struct S; 

template <typename T, typename... U> 
struct S<T, U...>: S<U...> { 
    using S<U...>::f; 

    template<void(*F)(const T &)> 
    void f() { } 
}; 

template<> 
struct S<> { 
    void f(); 
}; 

template<typename... T> 
struct R: S<T...> { 
    using S<T...>::f; 

    template<typename U, void(*F)(const U &)> 
    void g() { 
     this->template f<F>(); 
    } 
}; 

void h(const double &) { } 

int main() { 
    R<int, double> r; 
    r.g<double, h>(); 
} 

それはGCC 4.9（hereを参照）でコンパイルが、それは打ち鳴らす3.8でコンパイルされません。 .（here参照）。

正しいコンパイラとその理由は何ですか？
さらに、両方のコンパイラでコンパイルされたコードを見るにはどうすればよいですか？

Answer 1

ここではclangが正しいと思いますが、これはgccのバグです。宣言を使用しては、派生クラス、メンバ関数と メンバ関数テンプレートに、基本クラスからの宣言をもたらした場合

：[namespace.udecl]から

struct U { 
    template<int > void foo() { } 
}; 

struct X : U { 
    using U::foo; 
    template<void* > void foo() { } 
}; 

int main() { 
    X{}.foo<1>(); // gcc ok, clang error 
} 

：まずは、簡単な例から始めましょう派生クラスのメンバー関数とメンバ関数をオーバーライドまたは非表示にする ベースクラスの同じ名前、パラメータタイプリスト（8.3.5）、cv-qualification、およびref-qualifier（存在する場合）を持つテンプレート紛争よりむしろ）。そのような隠蔽された宣言またはオーバーライドされた宣言は、宣言によって導入された 宣言のセットから除外されます。 、CV-資格（なし）、及びREF修飾子（なし）;

U::fooとX::fooは、同じ名前、パラメータ型リスト（なし^{＆ダガー）を有します。したがって、X::fooは、オーバーロードするのではなくU::fooを隠します。間違ったタイプを間違いなくX::fooに渡しています。単に別の関数ポインタ型でのオーバーロード（というよりもテンプレートパラメータとしてそれらを取る）}

が正常に動作します：

template <typename T, typename... U> 
struct S<T, U...> : S<U...> { 
    using S<U...>::f; 

    void f(void (*F)(const T&)) { } 
}; 

それとも、本当にテンプレート引数として関数ポインタが必要な場合は、まだでそれらをラップすることにより、過負荷になる可能性がありタグタイプ：

template <class T> 
using fptr = void(*)(const T&); 

template <class T, fptr<T> F> 
using func_constant = std::integral_constant<fptr<T>, F>; 

て、それを介して伝播：

template <typename T, typename... U> 
struct S<T, U...>: S<U...> { 
    using S<U...>::f; 

    template <fptr<T> F> 
    void f(func_constant<T, F>) { } 
}; 

と：

template <class U, fptr<U> F> 
void g() { 
    this->f(func_constant<U, F>{}); 
} 

^＆短剣。parameter-type-listの定義にはテンプレートパラメータは記載されていません。@barry後

Answer 2

- にS専門にfの定義を変更：

template <typename T, typename... U> 
struct S<T, U...>: S<U...> { 
    using S<U...>::f; 


    template<void(*F)(const T &)> 
    void f(T *= nullptr) { } 
}; 

また、あなたのコードで作業を打ち鳴らすことができます。

編集：

template <typename T, typename... U> 
struct S<T, U...>: S<T>, S<U...> { 
}; 

template<typename T> 
struct S<T> { 
    template<void(*F)(const T &)> 
    void f() { } 
} 

そして使用gであなたのfメソッドを呼び出します：

S<U>::template f<F>(); 

使用を

あなたが専門分野を変えることができるコードがさらに簡単にするためにこのオプションはさらに進んでいくことができます。@ barryはタグのディスパッチを使用することを提案しましたが、私はn個のテンプレートパラメータではなく、機能のPARAMTERとして：

template <typename... T> 
struct S; 

template <typename T> 
struct footag { }; 

template <typename T, typename... U> 
struct S<T, U...>: S<footag<T>>, S<U...> { 
}; 

template<typename T> 
struct S<T>:S<footag<T>> { 
}; 

template<typename T> 
struct S<footag<T>> { 
    template <void (*F)(const T&)> 
    void f() { } 
}; 

template<typename V, typename... T> 
struct R: S<V, T...> { 
    template<typename U, void(*F)(const U &)> 
    void g() { 
     S<footag<U>>::template f<F>(); 
    } 
}; 

void h(const float &) { } 

int main() { 
    R<int, float, double> r; 
    r.g<float, h>(); 
}