Creating variadic accepting only reference or pointer

Question

I can create a variadic template that accepts only pointers:

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

Or a variadic template that accepts only references:

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

How can I create a template that accepts either non-const reference or pointer?
E.g.

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

Note: The reference version might seem ok because it can bind to pointer references but it is not since it will not bind to int * const

I think you should accept generic `Types...` and then check their being pointers or reference through something like `std::is_pointer` — Paolo M, Aug 28 '15 at 09:31

score 6 · Accepted Answer · edited May 23 '17 at 12:06

We can write a trait to check if a type is a pointer or a non-const reference:

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

Then we can write a trait to check this over a parameter pack using Jonathan Wakely's and_:

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>...>;

Now we can use std::enable_if to validate the type:

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

Note that the forwarding reference is necessary to detect the value category of the argument so that the reference check works correctly.

Live Demo

By *forwarding reference* you mean *universal reference* i.e. the `Types&&`? — Paolo M, Aug 28 '15 at 09:44
@PaoloM yes, but I believe "forwarding reference" is the [preferred term now](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4164.pdf). — TartanLlama, Aug 28 '15 at 09:45

score 1 · Answer 2 · answered Aug 28 '15 at 09:35

1

You can simply check the requirements for each type in Args - e.g. 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>>{}...>{}>
{}

Assuming that F is used with deduction only, solely lvalues and pointers will be allowed. Demo with your example.

answered Aug 28 '15 at 09:35

Columbo

60,038
8
155
203

I think you need to check if the referenced type is marked `const`, as this will allow calling with `const int a; F(a);` – TartanLlama Aug 28 '15 at 09:42
@TartanLlama I think his intention was to not allow rvalues. – Columbo Aug 28 '15 at 09:47
ah, you're probably right. It's an easy fix to either answer if OP wants to make one anyway. – TartanLlama Aug 28 '15 at 09:50

Creating variadic accepting only reference or pointer

2 Answers2