Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?

This question is about guaranteeing all arguments are of the same type while exhibiting a reject-early behavior with a clean compiler error, not a template-gibberish error

I'm creating a function (possibly member function, not that it matters... maybe it does?) that needs to accept an unknown number of arguments, but I want all of them to be the same type. I know I could pass in an array or vector, but I want to be able to accept the list of args directly without extra structure or even extra brackets. It doesn't look like variadic functions by themselves are typesafe, and I wasn't sure how to go about this w/ variadic template functions. Here's essentially what I'm aiming for (more than likely not correct code, and totally not for the purpose of getting lists of dragons, lol):

//typedef for dragon_list_t up here somewhere.

enum Maiden {
    Eunice
    , Beatrice
    , Una_Brow
    , Helga
    , Aida
};

dragon_list_t make_dragon_list(Maiden...) {
    //here be dragons
}

OR

template<Maiden... Maidens> dragon_list_t make_dragon_list(Maidens...) {
    //here be dragons
}

USAGE

dragon_list_t dragons_to_slay
    = make_dragon_list(Maiden.Eunice, Maiden.Helga, Maiden.Aida)
;

Tried a few things similar to the above already, no dice. Suggestions? Obvious oversights I may have made? I know it may not be a huge deal to do this instead:

dragon_list_t make_dragon_list(std::array<Maiden> maidens) {
    //here be dragons.
}
dragon_list_t dragons_to_slay
    = make_dragon_list({Maiden.Eunice, Maiden.Helga, Maiden.Aida})
;

but I'd much rather be able to do it the first way if possible.

You can just accept the arguments by the variadic template and let typechecking check the validity later on when they are converted.

You can check convertibility on the function interface level though, to make use of overload resolution for rejecting outright wrong arguments for example, by using SFINAE

template<typename R, typename...> struct fst { typedef R type; };

template<typename ...Args>
typename fst<void, 
  typename enable_if<
    is_convertible<Args, ToType>::value
  >::type...
>::type 
f(Args...);

For your use-case if you know the steps to go from an std::array<> to your dragon_list_t then you have already solved it though according to the first option above ("convert-later"):

template<typename ...Items>
dragon_list_t make_dragon_list(Items... maidens) {
    std::array<Maiden, sizeof...(Items)> arr = {{ maidens ... }};
    // here be dragons
}

If you combine this with the above is_convertible approach you have a reject-early template that also does overload resolution on arguments and rejects them if not applicable.

If you don't use template on the parameter not in the pack the variadic function will resolve to have all arguments of the same type.

Here's an example for an extended max function that only accepts ints (or types convertible to int).

int maximum(int n) // last argument must be an `int`
{
    return n;
}

template<typename... Args>
int maximum(int n, Args... args) // first argument must be an int
{
    return std::max(n, maximum(args...));
}

---

Explanation: When you unpack the argument pack (args...) the compiler looks for the best overload. If the pack had only one parameter then the best candidate is maximum(int) so the only parameter must be and of type int (or convertible to int). If there are more than one elements in the pack then the only candidate is maximum(int, typename...) so the first argument must be of type int (or convertible to int). It's simple to prove by induction that all the types in the pack must be of a type convertible to int.

Since you've included the C++0x tag, the obvious answer would be to look up initializer lists. An initializer list lets you specify a number of arguments to a ctor that will be automatically converted to a single data structure for processing by the ctor.

Their primary (exclusive?) use is for exactly the sort of situation you've mentioned, passing a number of arguments of the same type to use in creating some sort of list/array/other collection of objects. It'll be supported by (for one example) std::vector, so you could use something like:

std::vector<dragon> dragons_to_slay{Eunice, Helga, Aida};

to create a vector of three dragon objects. Most (all?) of the other collections will include the same, so if you really insist on a list of dragons you should be able to get that pretty easily as well.

A recent proposal, Homogeneous variadic functions, addresses this by making something like your first construct legal. Except of course to use the parameter pack you will have to name it. Also the exact syntax doesn't seem very concrete yet.

So, under the proposal this will actually be legal (you can see a similar construct in the paragraph "The template introducer" in the paper):

dragon_list_t make_dragon_list(Maiden... maidens) {
    //here be dragons
}

I recently needed to constrain a parameter pack to be only one type, or at least convertible to that type. I ended up finding another way:

#include <type_traits>
#include <string>

template <template<typename> class Trait, typename Head, typename ...Tail> 
struct check_all {
  enum { value = Trait<Head>::value && check_all<Trait, Tail...>::value };
};

template <template<typename> class Trait, typename Head>
struct check_all<Trait, Head> {
  enum { value = Trait<Head>::value };
};

template <typename ...Args> 
struct foo {
  // Using C++11 template alias as compile time std::bind
  template <typename T>
  using Requirement = std::is_convertible<double, T>;
  static_assert(check_all<Requirement, Args...>::value, "Must convert to double");
};

int main() {
  foo<int, char, float, double>();
  foo<int, std::string>(); // Errors, no conversion
}

The thing that I liked about this solution is that I can apply check_all to other traits too.

using c++17, you can write

template <class T, class... Ts, class = std::enable_if_t<(std::is_same_v<T, Ts> && ...)>
void fun(T x, Ts... xs)
{
}

Although the question is tagged C++11, I think a C++20 + concepts solution would be worth adding seeing as though there is now support in GCC and others will soon follow.

first define a simple concept

class mytype{};

template<typename T>
concept MyType = std::is_same<T, mytype>::value;

then simply use variadic template parameters

template<MyType ... Args>
void func(Args &&... args){
    // do something here
}

Much easier with the advent of concepts!

This is almost direct alternative to (Maiden...).

dragon_list_t make_dragon_list()
{
    return dragon_list_t();
}
template<typename ...T>
auto make_dragon_list(Maiden first, T &&... other) -> decltype(make_dragon_list(std::forward<T>(other)...))
{
    //here be dragons
    return {first, std::forward<T>(other)...};
}

but it still does not support the construction by multiple variables. If Mained was a class, that can be constructed from 2 variables, when

make_dragon_list({1,0}) 

will work, but

make_dragon_list({1,0}, {2,3}) 

won't compile.

This is why this proposal so important

The code below will work using C++20 Concepts. Compile with the -std=c++20 flag.

#include <concepts>
#include <vector>

enum Maiden {
  Eunice
  , Beatrice
  , Una_Brow
  , Helga
  , Aida
};

using dragon_list_t = std::vector<Maiden>;

dragon_list_t make_dragon_list(std::same_as<Maiden> auto... xs) {
  return {xs...};
}

int main(int argc, char *argv[])
{
  make_dragon_list(Helga,Aida,Aida);
  return 0;
}

This uses the std::same_as concept from the C++20 standard library. You can also use the std::convertible_to concept if you want more flexibility.

It really depends what you're trying to implement, exactly.

Usually enum indicates runtime subtypes of a particular class, or a discriminated union (boost::variant). But in this case, you want to pass the enum directly. Moreover, you have a limited set of possible values, and each function call forms a subset. Really what you are representing is one subset, not several parameters at all.

The best way to represent a subset of a finite set is a bitset. Large sets should use std::bitset; small sets can just use unsigned long.

enum Maiden_set {
    Eunice = 1,
    , Beatrice = 2
    , Una_Brow = 4
    , Helga = 8
    , Aida = 16
};

dragon_list_t make_dragon_list(Maiden_set) {
    //here be dragons
}

make_dragon_list( Eunice + Beatrice + Helga );

or, since you appear to want to handle variation at compile time,

template< int Maidens > // parameter is not a Maiden_set because enum+enum=int
dragon_list_t make_dragon_list() {
    //here be dragons
}

make_dragon_list< Eunice + Beatrice + Helga >(); // + promotes each enum to int

It should be possible to generate the powers of 2 automatically using an operator+ overloaded on the enum type. But I'm not sure I'm on the right track at all.

In short, you should probably just create a vector. It isn't that much overhead, especially if you use something like boost::list_of or C++0x's initializer list. The syntactic overhead is minimal, and it is more flexible (you could pass list with a number of arguments known only at runtime).

If you really wanted, you could use variadic template parameters to do this:

// Using pass-by-value since I'm assuming it is primitive:

template< typename T, typename... Args>
void make_dragon_list_internal( dragon_list_t* dragon_list, T t, Args... args )
{
   // add T to dragon_list.
   make_dragon_list_internal( dragon_list, args... );
}

void make_dragon_list_internal( dragon_list_t* dragon_list )
{
   // Finalize dragon_list.
}

template<typename... Args>
dragon_list_t make_dragon_list( Args... args )
{
  dragon_list_t dragon_list;
  make_dragon_list_internal( &dragon_list, args... );
  return dragon_list;
}

It's typesafe, and extensible (you could make this take things other than dragons, if you feel like).

I would try to keep things simple, and the simplest solution I can think of is just using a plain old vector. By using C++0x features you can get a syntax that is similar to (even if not exactly) what you want:

void foo( std::vector<int> const & v ) {
   std::copy( v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " ") );
}
int main() {
  foo({ 1, 2, 3, 4, 5, 6 }); // note the extra {}
}

C++20 concepts makes it as nice as

template<std::same_as<Maiden>... T>
dragon_list_t make_dragon_list(Maiden...) {
    //here be dragons
}

https://gcc.godbolt.org/z/EKzWME

I think the following code is helpful for your case:

template <class...>
struct IsAllSame {};

template <class T, class B1>
struct IsAllSame<T, B1> {
  static constexpr const bool kValue = std::is_same<T, B1>::value;
};

template <class T, class B1, class... Bn>
struct IsAllSame<T, B1, Bn...> {
  static constexpr const bool kValue =
      IsAllSame<T, B1>::kValue ? IsAllSame<T, Bn...>::kValue : false;
};

IsAllSame<int>::kValue == true
IsAllSame<bool, int>::kValue == false
IsAllSame<bool, int, int>::kValue == false

A more general way to do this, without extra assumptions (like they are one certain, specific type) is to use a modern C++20+, requires clause, which to me sounds like the next best thing to having this built into the language in a more intuitive way.

Ideally, you could use std::same_as<Ts...> (concept) or std::is_same<Ts...> (type-trait), but in actuality you cannot because the standard doesn't provide them as variadic for some reason. (I'm not sure why; it's kind of annoying.)

So we will implement our own and then maybe get around to writing a proposal for the standard, because they are fundamental. We'll call them all_same (concept) and are_same (type-trait).

Here's how to use them:

template<typename... Ts> requires all_same<Ts...>
someFunction(Ts... ts){}

Which is pure C++20 style, using the concept. Or, a mix of C++20 and C++17:

template<typename... Ts> requires are_same_v<Ts...>
someFunction(Ts... ts){}

If you're stuck in C++17, then you could use SFINAE:

template<typename... Ts, std::enable_if_t<std::are_same_v<Ts...>, void>>
someFunction(Ts... ts){} // I feel so dirty

Implementations

C++20 Concept version.

template<typename... Ts>
concept all_same =
    (std::same_as<typename std::tuple_element_t<0, std::tuple<Ts...>>, Ts> && ...);

C++17 type-trait version.

template<typename... Ts>
struct are_same : std::integral_constant<bool, (std::is_same_t<typename std::tuple_element_t<0, std::tuple<Ts...>>, Ts> && ...)>
{};

template<typename... Ts>
inline constexpr bool are_same_v = are_same<Ts...>::value;

The implementation of our variadic are_same type-trait is written in terms of the binary std::is_same type trait. This could be quite useful for pre-C++20 code, but then of course you won't be able to use the requires keyword for it. Still useful by using SFINAE (std::enable_if) in lieu of concepts and C++20, and for other metaprogramming tasks.

What both of these do is use the tuple template facilities--which are metaprogrammatic in nature--to extract information about the type of the first element of the variadic pack, and then compare that against all the other types in the pack to ensure they are identical. There is no runtime overhead. This is all compile time.

void testFunction()
{
    someFunction(4, 38, 58); // Fine.
    someFunction("hello", "world", "how are you?"); // Fine.
    someFunction("wtf", 28, 482.3); // Error!
}

The first two work because all arguments are the same type. The third one fails with a compiler error because they aren't.