Object creation order in braced init list

Question

#include <iostream>

struct A
{
    A() { std::cout << "(A::A)"; }
};

struct B
{
    B() { std::cout << "(B::B)"; }
};

struct C
{
    template<typename ...Args>
    C(Args && ...) {}
};

int main(int agrc, char *argv[])
{
    C {A(), B()}; // <-- prints (B::B)(A::A)
    std::cout << std::endl;
    C {(A(), B())}; // <-- prints (A::A)(B::B)
    std::cout << std::endl;

    return 0;
}

I've got 2 questions:

Why in first braced init list objects are created in right-to-left order?
Why parentheses in second case revert this order?

Edit: I've compiled it with msvs 2013

@dyp Doesnt `C {A(), B()}; // <-- prints (B::B)(A::A)` contradict what you just said? — Borgleader, Jan 20 '14 at 12:44
I think the output of the first line shows a bug - according to 8.5.4/4, it should be evaluated left to right. — jrok, Jan 20 '14 at 12:45
@dyp. I don't think so. `In list-initialization, every value computation and side effect of a given initializer clause is sequenced before every value computation and side effect associated with any initializer clause that follows it in the comma-separated list of the initializer list.` — sliser, Jan 20 '14 at 12:45
@DeadMG - Simple solution is not to write crap code in the first place — Ed Heal, Jan 20 '14 at 12:48
@EdHeal: that is not crap code. I use them (list-initialization) in generic code : `sink { args ... };` is the new idiom! — Nawaz, Jan 20 '14 at 12:51
@EdHeal: Try writing variadic templates, then you will realize the power of *braced-init-list*. — Nawaz, Jan 20 '14 at 13:03
@Nawaz: It was a funny joke changing "idiom" to "idiot". Don't worry about it ;) — Lightness Races in Orbit, Jan 20 '14 at 13:03
@Nawaz Just look at LRO's avatar - "Michael" is clearly not an appropriate name for a female Vulcan. — Casey, Jan 20 '14 at 20:10
possible duplicate of [Order of evaluation of elements in list-initialization](http://stackoverflow.com/questions/14060264/order-of-evaluation-of-elements-in-list-initialization) — Casey, Jan 20 '14 at 20:11

Lightness Races in Orbit · Accepted Answer · 2014-01-20T12:58:37.400

In the second instance, you're actually only initialising with B(); through the use of the comma operator, A() was constructed and thrown away first.

C {(A(), B())};
//|^^^^^^^^^^|
//      \--------> (A(), B())
//                  ^^^  ^^^
//                   |    |
//                   /    \
//            evaluated,   THEN evaluated,
//            discarded      used

On the other hand, in the first instance, you're initialising the C from both temporaries through an initializer list, whose elements should also be evaluated left-to-right, as it happens, but your compiler is buggy in this regard:

[C++11: 8.5.4/4]: Within the initializer-list of a braced-init-list, the initializer-clauses, including any that result from pack expansions (14.5.3), are evaluated in the order in which they appear. That is, every value computation and side effect associated with a given initializer-clause is sequenced before every value computation and side effect associated with any initializer-clause that follows it in the comma-separated list of the initializer-list. [ Note: This evaluation ordering holds regardless of the semantics of the initialization; for example, it applies when the elements of the initializer-list are interpreted as arguments of a constructor call, even though ordinarily there are no sequencing constraints on the arguments of a call. —end note ]

I can reproduce the problem with GCC 4.8^*, but Clang 3.5 behaves properly^†. The bug has been discussed on the std-discussion list before^&ddagger;, but I haven't found a GCC Bugzilla ID yet^§.

C {A(), B()};
// ^^^  ^^^
//  |    \
// eval-  THEN
// uated   evaluated
//  \       /
//   \     /
//  both used

^{^* http://coliru.stacked-crooked.com/a/1f18e0d1f8973f3c}
^{^† http://coliru.stacked-crooked.com/a/5a6e7506e9be97c3}
^{^&ddagger; https://groups.google.com/a/isocpp.org/forum/#!topic/std-discussion/TQUnBFkUBDg}
^{^§ #51253 may be related.}

Yes. I like ASCII arts, I also use a [tool](http://www.asciiflow.com/#Draw) to draw :). btw congrats for 100K+, last time I saw you somewhere around 98k. — Grijesh Chauhan, Jan 20 '14 at 13:53
[#51253](http://gcc.gnu.org/bugzilla/show_bug.cgi?id=51253) is exactly this bug. See live example for [gcc](http://coliru.stacked-crooked.com/a/c87a94584bb7db40) and [clang](http://coliru.stacked-crooked.com/a/116391f92c850380), taken from the bug's testcase. — iavr, Apr 04 '14 at 23:12

Nawaz · Answer 2 · 2014-01-20T12:49:55.323

5

Why in first braced init list objects are created in right-to-left order?

No. It is left-to-right. Your compiler has bug which is why it is evaluating right-to-left. GCC (4.8) is known to have this bug. Do you use GCC?

Why parentheses in second case revert this order?

Same. Left to right. In this case, comma operator comes into picture, which evaluates operands left-to-right.

edited Jan 20 '14 at 12:49

answered Jan 20 '14 at 12:44

Nawaz

353,942
115
666
851

compiled with msvs 2013 – sliser Jan 20 '14 at 12:47
1

@sliser: then that too has bug (assuming what you said it true). – Nawaz Jan 20 '14 at 12:48

Vlad from Moscow · Answer 3 · 2014-01-20T13:07:14.620

It is an old bug of gcc 4.8.1 ( I suppose you use GCC) or of other compiler. I wrote about this bug several months ago the initializer-list: a bug of GCC 4.8.1

Though it is written in Russian but you can translate it into English using for example google service translate.

As it was said by others elements of the initializer-list are evaluated from left to right and all side effects are applied before evaluation of the next element.

In your second code example you in fact call the constructor with one expression that is an expression of the comma operator. The comma operator in fact behaves the same way as initializer-lists that is it evaluates its operands from left to right and applies side effects before evaluation of the next operand.

Object creation order in braced init list

3 Answers3

Linked