C++ varadic templates mixing values, arrays and objects - c++

Question

I would like to initialize a class with a mix of basic types, arrays and sub-structures like
A a { 1, // int
1.2, // double
"Hello", // const char *
{ 1, 2, 3 }, // array<int>
{ 1.2, 2.4 } // array<double>
{ 1, 1.2, "Hello" } // sub-structure of any types
};
where the sub-structure should be able to contain nested sub-structures as well.
For the basic types I can do that with variadic templates:
#include <iostream>
class A {
public:
template <class T, class... Args>
void print(T v) {
std::cout << v << std::endl;
}
template <class T, class... Args>
void print(T v, Args... args) {
std::cout << v << std::endl;
print(args...);
};
template <class T, class... Args>
A(T v, Args... args) {
print(v, args...);
};
};
int main() {
A a { 1,
1.2,
"Hello",
};
}
which correctly produces
1
1.2
Hello
But I fail for arrays and sub-structures. I'm restricted to C++11. Any help highly appreciated.

Answer 1

{/*..*/} has no type, and so cannot be deduced in template except for std::initializer_list<T> or C-array T(&)[N].
So for variadic template, as you cannot provide all those combination of overloads, you have to provide type, and as you are using template constructor, only in the type itself:
A a { 1, // int
1.2, // double
"Hello", // const char *
std::array<int, 3>{1, 2, 3 }, // array<int>
std::array<double, 2>{ 1.2, 2.4 } // array<double>
MyClass{ 1, 1.2, "Hello" } // sub-structure of any types
};
C++17, with CTAD, allows std::array{1, 2, 3} instead of std::array<int, 3>{1, 2, 3}.

Answer 2

From cppreference:
A braced-init-list is not an expression and therefore has no type,
e.g. decltype({1,2}) is ill-formed. Having no type implies that
template type deduction cannot deduce a type that matches a
braced-init-list, so given the declaration template void
f(T); the expression f({1,2,3}) is ill-formed.
So, as #Jarod42 has mentioned, you need to explicitly provide the type. You can also use an auto variable beforehand to deduce the type (e.g. into std::initializer_list<int>) and then pass the variable into the constructor.

Answer 3

This won't fit in a comment so I post it as an answer. What you call a main structure isn't a structure (or type) at all but a form on initialization. Namely list initialization. The values between the braces are matched against your constructor and since you have a constructor with variadic template arguments, your code compiles. Another reason is, that you only provide literals, and literals have very well defined types: int, const char[N], float, ... . The compiler already knows those types without you having to provide a type.
Now add another level of braces, for example:
{ 1, 2, { 3, 4, 5 }, "test" }
According to the rules of list initialization (which is used because of your outer pair of braces), the compiler now looks for a constructor that matches this signature:
Ctor(int, int, <unknown>, const char*)
As you can see the compiler doesn't know what type {3, 4, 5} is so it tries to find a constructor that at least matches all other arguments. If it finds one, it tries to pass the <unknown> part to whatever type the matched overload has at that position in the parameter list. This will then trigger another list initialization on that specific parameter and the whole process repeats itself.
Lets take our example list from above
{ 1, 2, { 3, 4, 5 }, "test" }
and a set of constructors
Ctor(int, float*, int, const char*); // A
Ctor(int, int, int, const char*); // B
Ctor(int, int, std::array<int, 3>, const char*); // C
Now the compiler tries to match all known types to the imaginary signature we defined above (yes const char* is not the actual type of the literal but we ignore that here):
Ctor(int, int, <unknown>, const char*)
Option A is ruled out immediately, because the types of the 2nd argument do not match, so we're left with B and C. For B and C both signatures match the known types, so we're left figuring out what <unknown> could be. B offers us an int and C std::array<int, 3>. Lets check out B: can we do int x{3, 4, 5} (this is a simplification and just for illustration purposes)? Turns out C++ doesn't allow us to do that, so we discard B as an option. Next is C: can we do std::array<int, 3> x{3, 4, 5}. That looks right, C++ allows us to do that. We found a possible match for <unknown> and the compiler selects C as the constructor to be invoked. Great!
Now lets declare a variadic template constructor
template <typename ...Args>
Ctor(Args&&... args);
and match that against our list. Since we have template parameters, we basically tell the compiler: take whatever type the argument gives us. So we do that. The first two and the last arguments are easy, they're just literals so we have
template <typename Arg3>
Ctor(int, int, Arg3&& arg3, const char*);
Now we try out our nested list. The argument is <unknown> because the compiler couldn't figure out what {3, 4, 5} is (we leave std::initializer_list out here as a special case). The template parameter says: take whatever the type of that argument is, and the argument type is <unknown>. Do you spot the problem?

Answer 4

I post this as an answer since I need code formatting. I fully understand that the way I want to do this does not work. I would not have started if I would not have seen this before:
#include <iostream>
#include <json.hpp>
using json = nlohmann::json;
int main() {
json j {
{ "Float", 1.2},
{ "Int", 2},
{ "List", { 1,2,3 }},
{ "Object", {
{ "First", 3 },
{ "Name", "Joe"}
}}
};
std::cout << j << std::endl;
}
This is from https://github.com/nlohmann/json and used varadic templates. It nicely produces this output:
{"Float":1.2,"Int":2,"List":[1,2,3],"Object":{"First":3,"Name":"Joe"}}
So there must be a way to make this work. Unfortunately my mind is too poor to understand the code used by that library.