C++11 vector push_back ambiguous

Question

Consider the following code:

#include <vector>

struct S { int a; double b; };

int main()
{
    std::vector<S> v;
    v.push_back({3, 4.5});
}

g++ 4.4 complains that the call to push_back() is ambiguous:

error: call of overloaded ‘push_back(<brace-enclosed initializer list>)’ is ambiguous
note: candidates are: void std::vector<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = S, _Alloc = std::allocator<S>]
note:                 void std::vector<_Tp, _Alloc>::push_back(_Tp&&) [with _Tp = S, _Alloc = std::allocator<S>]

Is this supposed to be ambiguous according to the Standard, or is this just an issue with g++?

I know it can be resolved by writing in the type of S explicitly:

v.push_back(S{3, 4.5});

but the type name of S may be long, so I'd rather not do that...

Answer 1

Does S have to be a POD? If not, define a constructor, and it should work.

struct S
{
    int a;
    double b;

public:

    S(int a, double b) : a(a), b(b) {}
};

Also, v.push_back({3, 4.5}) is probably less efficient than v.emplace_back(3, 4.5) .

---

Update : Smells like a compiler bug. It works perfectly well with g++ 4.6.0 20101025 (experimental).

Answer 2

With the most recent draft (n3225), your code is in fact ambiguous. The candidates that are in vector will be

void push_back(const S& x);
void push_back(S&& x);

The question is: Is a list-initialization of a const S& a better/worse conversion sequence than a list-initialization of a S&& ? Overload resolution will make both conversions user defined conversion sequences . This means they are not comparable because there is no rule that can do so.

This is handled by core issue #1079 . If that issue gets accepted, the intention is that your code calls the second candidate. Incidentally, Jason Merril is a GCC developer :)