Uniform initialization syntax difference

Question

What's the difference between doing

A a{ A() };

and,

A a( A{} );

to avoid the Most Vexing Parse? When should I use a particular one?

In this particular situation, the simplest option would be `A a;`, right? If I don't misunderstand this, the syntax you suggest makes only sense when the temporary you want to pass to the constructor of `A` is of a different type than `A`, correct? I.e. `A a { B() };`. — jogojapan, Jun 04 '13 at 02:33

Andy Prowl · Accepted Answer · 2013-05-31T22:55:07.097

13

The two syntaxes are equivalent in most situations, and which one to choose is mostly a matter of taste. If you are into uniform initialization, I would suggest doing:

A a{ A{} };

Otherwise, parentheses alone can be used to disambiguate:

A a((A())); // This can't be parsed as a function declaration

Notice, that there is one situation (very unlikely, I must say) where the two forms shown in your question are not equivalent. If your class A has a constructor that takes an initializer_list<A>, that constructor will be favored over the copy constructor when the braces are used:

#include <initializer_list>
#include <iostream>

struct A
{
    A() { }
    A(std::initializer_list<A> l) { std::cout << "init-list" << std::endl; }
    A(A const& a) { std::cout << "copy-ctor" << std::endl; }
};

int main()
{
    A a(A{}); // Prints "copy-ctor" (or nothing, if copy elision is performed)
    A b{A()}; // Prints "init-list"
}

The above difference is shown in this live example.

edited May 31 '13 at 22:55

answered May 31 '13 at 22:49

Andy Prowl

124,023
23
387
451

2

Actually, the first *doesn't* print "copy-ctor" for me. I think its copy-elision. – Me myself and I May 31 '13 at 22:51
@MemyselfandI: Huh, right, the compiler is eliding the copy - but conceptually, the copy constructor is picked – Andy Prowl May 31 '13 at 22:53
Does copy-elision only happen when optimizations are enabled? – Me myself and I May 31 '13 at 22:57
1

@MemyselfandI: No. On many compilers it will always be enabled unless you specifically disable it. – Mankarse May 31 '13 at 22:58
@MemyselfandI: Not necessarily. Copy elision happens completely at your compiler's discretion, but it is *more likely* to happen when optimizations are enabled – Andy Prowl May 31 '13 at 22:58
@MemyselfandI: With GCC and Clang, you can force the compiler to inhibit copy elision by passing the flag `-fno-elide-constructors` – Andy Prowl May 31 '13 at 22:58
2

Be warned that `-fno-elide-constructors` is [currently broken](http://llvm.org/bugs/show_bug.cgi?id=12208) on clang. – Mankarse May 31 '13 at 23:00

score 9 · Answer 2 · answered May 31 '13 at 22:50

In most situations they are equivalent, but A a{ A() }; will prefer a std::initializer_list constructor if one is present, while A a( A{} ); will prefer a move/copy constructor.

When the construct ends up calling a move/copy constructor, the construction of the new object can be elided, but this is not possible for a std::initializer_list constructor.

Neither syntax will ever be parsed as a function declaration, so both avoid the most-vexing-parse.

#include <iostream>
#include <initializer_list>
struct A {
    A() {
        std::cout << "A()\n";
    }
    A(A&&) {
        std::cout << "A(A&&)\n";
    }
    A(std::initializer_list<A>) {
        std::cout << "A(std::initializer_list<A>)\n";
    }
};
int main()
{
    {A a{ A() };} // Prints "A()\n" "A(std::initializer_list<A>)\n"
    {A a( A{} );} // Prints "A()\n" and *possibly*
                  // (depending on copy elision) "A(A&&)\n"
}

Uniform initialization syntax difference

2 Answers2