Variadic şablonlar ve işlevler 'işaretçiler: hangi derleyici doğru?

Question

_{Daha iyi bir başlık bulamadım, ancak doğru fikre sahipseniz bunu değiştirmek için çekinmeyin. Olduğu gibi, GCC vs clang zaten daha iyidir.}

---

Bu kodda neyin yanlış olduğunu anlamaya çalışıyorum:

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>(); 
} 

O ile GCC 4.9 (here bakınız) derler, ama clang 3.8 ile derleme değil .0 (bkz. here). Hangi derleyici

sağ ve neden?
Ayrıca, hem derleyicilerle derleme kodunu görmek için ne yapabilirim?

Answer 1

O çınlama burada doğru olduğundan ve bu bir gcc hata olduğunu düşünüyoruz.

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 
} 

[namespace.udecl]: From: İlk olarak, basitleştirilmiş bir örnekle başlayalım

zaman bir türetilmiş sınıfa Temel sınıftan beyanlarını, üye fonksiyonları ve üye işlev şablonları getirir-beyanname kullanılarak türetilmiş sınıf geçersiz kılma ve/veya gizleme elemanı fonksiyonları ve aynı isimde şablonları elemanı işlevi, parametre tip listesi (8.3.5), ev yeterlilik ve temel sınıf ref-niteleyici (eğer varsa) (çatışmak yerine). Böyle gizli veya geçersiz beyanlar kullanarak-beyanname tarafından tanıtılan bildirimleri kümesinden dışlanır. , Ev yeterlilik (yok) ve ref eleme (yok);

U::foo ve X::foo aynı isim, parametre-tip listesi ( yok ^{ve kama) sahiptir. Dolayısıyla, X::fooyüklenerek yerineU::foo gizler ve kesinlikle X::foo içine yanlış türde geçiyoruz.}

Basitçe farklı fonksiyon işaretçisi türlerinde aşırı yüklenme (ziyade şablon parametreleri olarak onları alarak)

çalışıyor:

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

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

Yoksa gerçekten şablon argümanları olarak işlev işaretçileri gerekiyorsa, yine aşırı yük ile bunları sarabilirdiniz etiket türü:

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

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

ve yayılması:

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

ve:

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

^{ve kama;}parameter-type-list'un tanımı şablon parametrelerinden bahsetmiyor.@barry sonra

Answer 2

- için S uzmanlık f tanımını değiştirerek:

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


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

da koduyla çalışma tınlamak yapar.

Düzenleme:

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

Sonra kullanarak g içinde f yöntemi çağırmak:

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

kullanma

kod daha da basit size uzmanlık değiştirebilir hale getirmek için Bu seçenek bir adım daha ileri gidebilir ve @barry önerilen bir etiket kullanma önerisinde bulundu. yerine bir fonksiyonun bir Paramtre olarak daha n şablon parametresi: Tuhaf

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>(); 
}