trouble with constructing from initializer_list - c++

Question

I have a class which shall have many different constructor overloads, one of which is from an initializer_list. Unfortunately, this will be picked automatically when I use list-initialisation as in
class foo
{
template<typename T>
foo(T const&it);
template<typename T>
foo(std::initializer_list<T> list);
};
template<typename other>
foo bar(other const&it)
{
return {it};
}
when the second constructor is called, not the first. This is correct but counter intuitive and hence dangerous. How can I prevent that? I would be happy with a solution where the second constructor specialises for the case that list.size()==1. For example
template<typename T>
foo::foo(std::initializer_list<T> list)
: foo(list.begin(), list.size()) {}
template<typename T> // private constructor
foo::foo(const T*p, size_t n)
{
if(n==1)
foo::foo(p[0]); // this does not what I want
else {
/* ... */
}
}
where I try to explicitly call the first constructor from within another constructor. Is this possible? (the code compiles, but doesn't appear to call the intended constructor or in fact any constructor). The only way I could make this work was by using placement new:
template<typename T> // private constructor
foo::foo(const T*p, size_t n)
{
if(n==1)
::new(this) foo(p[0]); // seems to work
else {
/* ... */
}
}
However, this is at least inelegant if not outright dangerous. Are there better solutions?
Note that trying to replicate the effort of the first constructor instead of calling it is not really a useful solution, as there will be many different first constructors for different type of arguments using SFINAE.

Answer 1

Maybe you can use variadic template instead of initializer_list.
Something like:
#include <type_traits>
// equivalent to std::is_same but for more type.
template <typename... Ts> struct are_same : std::false_type {};
template <typename T> struct are_same<T> : std::true_type {};
template <typename T, typename ...Ts> struct are_same<T, T, Ts...> : are_same<T, Ts...> {};
class foo
{
struct dummy_t {};
public:
template <typename...Ts, typename = typename std::enable_if<(sizeof...(Ts) > 1) && are_same<typename std::decay<Ts>::type...>::value>::type>
foo(Ts&&... args);
template<typename T>
foo(T const&it);
};