Erstellen variadische nur Referenz oder Zeiger zu akzeptieren

Question

ich eine variadische Vorlage erstellen können, die nur Zeiger akzeptiert:

template<typename ... Types> 
void F(Types *... args); 

Oder eine variadische Vorlage, die nur Verweise akzeptiert:

template<typename ... Types> 
void F(Types &... args); 

Wie ich eine Vorlage erstellen das akzeptiert entweder nicht-const Referenz oder Zeiger?
Zum Beispiel

int a, b, c; 
F(a, &b); // => F<int &, int *> 
F(a, 3); // Error, 3 not pointer and cannot bind to non const-reference 

Hinweis: Die Referenzversion könnte ok erscheinen, weil es zu Zeiger Referenzen binden kann, aber es ist nicht, da es in Args für jeden Typ die Anforderungen überprüfen binden nicht einfach zu int * const

Answer 1

Wir haben eine Eigenschaft schreiben zu überprüfen, ob ein Typ ein Zeiger oder eine nicht konstante Referenz ist:

template <typename T> 
using is_pointer_or_ref = 
    std::integral_constant<bool, std::is_pointer<T>::value || 
    (std::is_lvalue_reference<T>::value && 
    !std::is_const<typename std::remove_reference<T>::type>::value)>; 

Dann können wir ein Merkmal schreiben diese über einen Parameter Pack Jonathan Wakely's and_ mit überprüfen:

template<typename... Conds> 
    struct and_ 
    : std::true_type 
    { }; 

template<typename Cond, typename... Conds> 
    struct and_<Cond, Conds...> 
    : std::conditional<Cond::value, and_<Conds...>, std::false_type>::type 
    { }; 

template <typename... Ts> 
using are_pointer_or_ref = and_<is_pointer_or_ref<Ts>...>; 

Jetzt können wir std::enable_if verwenden, um die Art zu bestätigen:

template<typename ... Types, 
    typename std::enable_if<are_pointer_or_ref<Types...>::value>::type* = nullptr> 
void F(Types&&... args){} 

Beachten Sie, dass die Weiterleitungsreferenz erforderlich ist, um die Wertkategorie des Arguments zu erkennen, damit die Referenzprüfung ordnungsgemäß funktioniert.

Live Demo

Answer 2

Sie - zum Beispiel thusly:

// Helper templates 
template <bool...> struct bool_pack {}; 
template <bool b, bool... rest> 
struct all_of : std::is_same<bool_pack<b, rest...>, bool_pack<rest..., b>> {}; 

template <typename... Args> 
auto F(Args&&... args) 
    -> std::enable_if_t<all_of<std::is_lvalue_reference<Args>{} 
          or std::is_pointer<std::decay_t<Args>>{}...>{}> 
{} 

Unter der Annahme, dass F nur mit Abzug verwendet wird, ausschließlich lvalues ​​und Zeiger werden dürfen. Demo mit Ihrem Beispiel.