How does the second form of c++ std::make_any work?

The reason this second for exists is due to std::initializer_list not playing well with template argument deduction. Imagine you own implementation (using std::make_any as an implementation) that does not offer the second form;

template< class T, class... Args > std::any poor_make_any(Args&&... args) { return std::make_any<T>(std::forward<Args>(args)...); } 

This works well for e.g.

struct Test { Test(std::initializer_list<int>) {} Test(int) {} }; std::any x = poor_make_any<Test>(42); 

but it fails to compile for

std::any x = poor_make_any<Test>({1, 2, 3}); 

again because std::initializer_list<int> cannot be deduced by the compiler. While you can always specify the second template argument, this is overly verbose for a function from the make_ family that is meant to be a deduction helper.

And finally, the remaining arguments are just additional flexibility that you get for free. Imagine this additional constructor for the Test example,

Test(std::initializer_list<int>, int) {} 

It just works with

std::any x = std::make_any<Test>({1,2,3}, 42); 

While if that variadic second part wasn't there, you had to

std::any x = std::make_any<Test, std::initializer_list<int>, int>({1,2,3}, 42); 

which is obviously not super convenient.