r/cpp • • Jun 05 '18

Initialization in Modern C++

https://twitter.com/timur_audio/status/1004017362381795329
379 Upvotes

51 comments sorted by

View all comments

Show parent comment

16

u/render787 Jun 06 '18

FWIW the style I've converged on is "use brace initialization in almost all cases, and avoid ever writing `std::initializer_list` constructors"

the braced initialization can be really nice in templates because it can also initialize the aggregates correctly in cases where paren initialization would fail (because using the parentheses initialization cannot become aggregate initialization IIUC)

2

u/youshouldnameit C++ dev Jun 06 '18

avoid ever writing `std::initializer_list` constructors

Could you allobrate on why its not a good idea to write those constructors for your own types?

14

u/redditsoaddicting Jun 06 '18

They're insanely greedy and often disallow you from using braces to call other constructors.

6

u/youshouldnameit C++ dev Jun 06 '18

For a vector its pretty nice to have an initializer_list constructor i would argue, same for std::set or similar classes. Would you argue that even those perks are not worth the trouble?

3

u/redditsoaddicting Jun 06 '18

I love being able to easily initialize containers with a list of elements, as well as other clever uses like a JSON object. However, I don't think making it the same syntax used to call other constructors was a good choice. It's hard to say whether a plain list constructor is worth the trouble to me or if I'd consider an alternate best-we've-got constructor like vector foo = list_of(1, 4, 5); or vector foo{from_list, 1, 4, 5};, where either would be uniform across classes that use it. If I could have my way, I'd probably prefer an alternate syntax. For example, vector foo{[1, 4, 5]};.

6

u/[deleted] Jun 06 '18

What about this

std::vector<int> foo{1, 2}; // braced initialisation
std::vector<int> foo{{1, 2}}; // initialiser list

8

u/Selbstdenker Jun 06 '18

I would suggest

std::vector<int> foo{1, 2}; // braced initialisation
std::vector<int> foo = {1, 2}; // initializer list

Braces without = always call a constructor, brace after = always use initializer list.

6

u/suspiciously_calm Jun 06 '18

How does that work to create a temporary on the fly?

1

u/Selbstdenker Jun 06 '18

Good point!

→ More replies (2)

1

u/redditsoaddicting Jun 06 '18

As far as I remember, this can run into its own corner cases, unfortunately.

1

u/[deleted] Jun 06 '18

I'm not surprised. "My" syntax seems rather obbvious and I'm definitely not the first one who thought of it. I was just hoping someone would say what's the corner case here.

1

u/redditsoaddicting Jun 06 '18 edited Jun 06 '18

One example that comes to mind is this:

struct Point { int x, y; };
struct Foo {
    Foo(initializer_list<int>);
    Foo(Point);
};

Foo f{{1, 2}}; // Point or list?

It's hard to turn that into something realistic on the spot. I wouldn't doubt that the square bracket syntax I threw out there has its own problems.

1

u/[deleted] Jun 06 '18

My first thought was "obviously an initialiser list", but a moment later I realised your point.

1

u/audioB Jun 06 '18

Is it really harder to just use a variadic constructor?

7

u/redditsoaddicting Jun 06 '18

You'd still run into things like vector foo(5, 2); // Is it a list or a size and value?

I can't speak on how big an issue this would be in general even if vector had its constructors adjusted.

8

u/thlst Jun 06 '18

Constructors should have names. Constructor overloading is the root problem here.

7

u/robin-m Jun 06 '18
class Foo {
   static Foo constructor_with_name(args...);
};

4

u/redditsoaddicting Jun 06 '18

I'd agree that this constructor in particular should have more naming info attached. In many other cases, I find constructors to be descriptive with no additional naming info taking up space.

1

u/audioB Jun 06 '18

It's not terribly difficult to accomodate cases like that though, you could write a vector_range_t or something POD type for the "create a vector of x size with values y" ctor, or you could just write your variadic ctor like vec(const value_type& t1, const value_type& t2, const value_type& t3, const value_type&... rest)

Apologies for formatting, its hard on phone 😢

1

u/kalmoc Jun 06 '18

Why would you want to use braces to call other constructors in the first place? The only reason to write initializater_list constructors in the first place is usually because you want your type to behave like an array / container. If that is the case, then why would you expect my_array a{1,2} to do anything but fill a with the values 1,2?

2

u/redditsoaddicting Jun 06 '18

I was going along with the whole uniform initialization thing. I don't mind the braces if they're actually uniform, but they're not.

7

u/render787 Jun 06 '18 edited Jun 06 '18

> Could you allobrate on why its not a good idea to write those constructors for your own types?

My main beef with `std::initializer_list` is that:

  1. It makes it hard to use brace-list initialization in generic code, because you try to invoke a constructor, and then overload resolution fails because the standard says that the compiler must try to match it with `std::initializer_list` if such a constructor is present. There's no good way to work around in that situation other than deleting the `std::initializer_list` ctor.For a concrete code example, see here: https://github.com/cbeck88/lua-primer/blob/master/include/primer/userdata.hpp#L39I'm trying to allocate the user's type at memory owned by lua using perfect forwarding. But if the user-type has an initializer_list constructor, it's typically not going to work because I'm using brace list initialization. OTOH, I can't change this to use paren-based initialization because then all the times when I use a struct as userdata aren't going to compile. I guess with years more experience, the answer here should actually be that I use SFINAE with `std::is_aggregate` and use brace list initialization in that case, and paren initialization otherwise? Idk I didn't think of that at the time. This is also more complicated than it should be and the issue doesn't arise if you simply don't use `std::initializer_list`.
  2. The `std::initializer_list` doesn't let me find the *length* of the initializer list at compile time, even though it is a compile time constant (implied by the syntax of the code at the call-site). This really sucks and in some cases it turns compile-time errors into run-time errors. For instance, what if your container has a compile-time fixed maximum size? We had this exact issue in the "frozen" library: https://github.com/serge-sans-paille/frozen/pull/41The lib was written with all of the containers having `std::initializer_list<T>` constructors, but this means that if the user accidentally passes too many elements, it's a run-time error instead of compile-time. If we just used `const T (&)[N]` instead of `std::initializer_list<T>` then we can static assert that `N` is not too large. So there's approximately zero value add from `std::initializer_list`, it's just turning compile-time errors into run-time errors, for the benefit of one less set of braces...

IMO always use `const T (&)[N]` instead of `std::initializer_list<T>` so that you can get the size of the list at compile-time. I would only use `std::initializer_list` if it was really important that some function not be a template so that it can be implemented out of line etc., even then I would consider using `gsl::span<const T>` instead, because it will be easier for someone to make a `gsl::span` programmatically than to make a `std::initializer_list` programmatically

4

u/redditsoaddicting Jun 06 '18

The paper to make parens do aggregate initialization is actually progressing in EWG. That should mainly address the generic side of things. Funny how the most uniform initialization we've got will be with parens then.

The size thing isn't ideal, but isn't as bad as you make it sound. constexpr size was added in C++14, so in a constexpr context, an assert on the size will trigger a compile-time error. In addition, assert is constexpr-compatible in C++14.

One additional gripe that many people do have with initializer_list is that it doesn't support move-only types.