I think this is because std::println deduces the second and third argument and imposes these template arguments into its first argument. Cppinsights shows this argument type of the called function because there is a conversion involved.

Try pinch to zoom👌

For your first point of compiler optimizing it away, I don't think that is true. You can test that be adding "-O3" to the compiler-explorer code in the description. Second point is correct. The reference will take space in a class.

@@imranjavaid71 You are diplaying the address of the pointer, so this is not a relevant example.

That's actually an accented way of saying it :)

Thanks! I think its to late to change.

Thanks! Unfortunately, I can't edit/update the already published video :-)

Well, because it was introduced a long time after C++98. In addition it is a save default. Once you start throwing exceptions which pass functions which are noexcept default things get hard.

Sarcasm? I don't get why you would want to use a macro and why use __builtin_source_location() in ::current. The compiler does that for you already.

@@andreas_fertig Then I was confused at 4:50 or so where you used it. The define is to avoid the extra typing or copy/pasting of lines 14, 15 of the same code in your right side window.

@@garyp.7501 You don't need to do that. The right side shows what the compiler makes of it behind the scenes.

Sorry about that!

so lets earn him a $5000 mic!

Your move-constructors and move-assignment operators are typically noexcept. That's the reason why we have noexcept in the first place.

Difference is that integral_constant<bool, true> and integral_constant<bool, false> are of different types.

With C++17 we can have "auto" as a non-type template parameter. This allows you to use a single parameter cppinsights.io/s/39165dba

@@andreas_fertig That's fantastic! Thank you for the answer )

Yes, we reduce the number of parameters by merging the minimum of a and b into a. Then, we grab the first parameter of the pack and pass it to b, reducing the number of parameters in the pack by one in each iteration. To your second part, it is convention. The ellipsis goes right to the entity it belongs to. In your example, the typename.

@@andreas_fertig Thank you very much for personally answering to my question! It is an honour for me.

You can zoom a video on KZbin on a phone.

@@phusicus_404 Write and we love reading source code on a 6 inch phone screen. Besides do you think the quality when you zoom in is going to be good enough to understand anything that you're reading in the source code. Don't be silly.

That's a good point! However, the std::string consumer must respect the string size, not the null terminator.

Awesome! Sometimes, I forget that I've published several episodes.

Thank you!

I agree, initializer lists are not designed to pass by reference. They are a view and not a container.

There are some downsides to this, but potentially the benefit holds their weight. See my comment above for details.

@@David_Friberg For some reason, I don't see your comment.

@@VincentZalzal Seems KZbin's overzealously censored my comment, and does so even when I try to repost it. Trying from another account. What I wrote was: Note that this technique may unexpectedly break the rule of zero, in the cases where it would otherwise apply. As you declare the copy assignment op (even when explicitly defining it as defaulted) you suppress the implicit declaration of a defaulted move ctor and defaulted a move assignment operator. A mitigation comes with a cost: adding additional boilerplate code to bring us into rule of five, even if all special members are explicitly defined as defaulted. As an additional niche pitfall, it may also make aggregates into non-aggregates from C++20 and onward, as we need only user-declare a ctor to disqualify the class as an aggregate. Whilst this technique makes sense semantically, syntactically it can add a lot of noise, particularly in environments (automotive, safety-critical) where rule guidelines such as AUTOSAR C++14 (rule A12-0-1) will enforce rule of five if you cannot stick to rule of zero. Whilst this seems to have been addressed in MISRA C++:2023, I'm still leaning towards mitigation for to-rvalue assignment being enforced by static analysis (fully decidable) instead of via a language measure that comes with this kind of cost.

@@VincentZalzal For some reason my other (explanatory) comment keeps getting censored by KZbin, no idea why. Instead, I posted it as a Q&A on r/cpp_questions, hopefully you can find it there.

@@David_FribergFound it, thanks.

My pleasure!

You're welcome!

The example is too simple for the compiler with -O3. Still, in a code base that does something with the optional, it depends on the compiler's ability to see through it. In the worst case, the compiler performs a call to an empty destructor. That might not cost much, but the costs increase if it affects caching because the destructor is not in the hot cache.

There is no guarantee that an optimizer must do a particular optimization. This simple example compiler-explorer.com/z/TGeWcxrcf leads to code the compiler cannot efficiently optimize even though Other could simply return 2.

As far as I know, yes. It's mostly about work the compiler has to do, which results in longer compile times. We want fast compilers. A compiler that deliberately creates non-required objects just so the optimizer can throw them away will not be as fast as the one that creates only what is required.

I'm not sure I understand your question.

@@andreas_fertig In the video you said the reason why the compiler does not deduce the const after the pointer is that it wants to increment/decrement it. My question is why the compiler wants to increment/decrement acicp at all? Because that is what necessitates the removal of the constness from the pointer.

​@@mohammadghasemi2402 Sorry, that was badly phrased. The compiler cannot ignore the fact that the pointer points to constant memory. We also made the pointer itself const, by adding a top-level qualifier. Hence we cannot increment or decrement the pointer. That top-level qualifier is not part of the type. That's what the compiler ignores.