วีดีโอ

ohh man, these are magic...

I hadn't know about this part of C++ Insights. Neat! Are there any other areas in C++ where this "anti-dangle" stuff is performed? If you did `get().items()` outside of this context, you'd still get a dangling ref, e.g. `auto &items = get().items(); auto b = items.begin(); // kaboom here`. I understand practically why this behavior is special-cased for the range for loop, but is this the only context in which it is done?

How do I use a third-party library (i.e. simdjson library) on c++ insights website? Thank you

फाॅन्ट आकाराने लहान आहे. वाचायला त्रास होतो.

I didn't know that trick or tool, now I do thank you!

Pedagogically speaking, I think that the analogy in the beginning can be clarified by saying that references and pointers are similar because they are both mechanisms of indirection. They are different, because the language doesn't treat them as assignable values. This separation of dimensions of likeness and difference maps onto the performance implications: indirection requires references to be represented as addresses in CPU in all but the most contrived usage scenario, so just like for pointers the indirection cost is there. But transient references don't need their own storage and can indeed ever only be in registers, which differs from pointers.

If you claim performance, show a benchmark! I'd say user strings are not long enough to note any significant difference

Am I the only one who is mesmerised by the std::basic_format_string template arguments mimicking the other arguments to std::println? What kind of sorcery is that?

I guess this can bring some clarity in which cases the program will do (or not do) life-time extension with `auto const&` and `auto&&`. Very nice.

सी ++ इनसाईट बहोत ही उपयुक्त है.

Nice video with very clear explanation.

I liked this video, quick and straight to the point

Your vids are unreadable on mobile screen size I wish it had bigger fonts.

Need to differentiate reference as a local variable vs an object member variable. Locally it can just be a name alias effectively. In an object, it's basically a pointer and you can actually get hacky and change what the reference references.

Interesting, but I think in most cases this does not make a difference: If the pointer is only used locally, the compiler should optimise storing it away if possible. Conversely if you have a class which stores a reference to something, this would take the same space as storing a pointer.

Great video sir. I think you might want to consider changing ‘no’ to ‘not’ in the title.

Thank you for the great explanation!

hi sir i wrote a generic code for stl containers but cpp insights it is not compiling can you please help me to solve it #include<iostream> #include <list> #include<vector> template<typename T,template<typename> class X> void print(X<T> &container){ for(auto &i: container) { std::cout<<i<<" , "; } std::cout<<" "; } int main(){ std::vector<int> a{1,2,3,4,5,6}; std::list<double> b{1.5,2.5,3.5,4.5,5.5,6.5}; print(a); print(b); return 0; }

That is a good tip if you want to make your assignments always use a reference to the object.

Why do we need this cast as const & binds to everything - even to non-const && (which is returned from std::move) ?

Why CppInsights puts a static_cast to const Apple&& and not to const Apple&, which is the argument of the copy constructor? Great video!

Great video! Is it possible to get a warning for this somehow? (though Clang Tidy or something). If I do std::move explicitly I wouldn't want it to be copied, at least not in non-template code. These kind of issues can be really had to spot :'D

Excellent example for if consteval, outlining with a practical use case the difference with std::is_constant_evaluated. It builds a clear bridge between the pure compile-time world and the hybrid compile-time/run-time world represented byt constexpr context. Great video, keep up the good work!

Awesome video. I don’t know if you have any interest or ability to edit the presentation at this point but there’s a missing ‘h’ in ‘tings’.

Nice !!

So why isn't noexcept the default?

Of course now I want to use a Macro to fill in the boiler plate code. #define LogMyError(x) LogError(std::operator""sv(x, 11UL), std::source_location::current(__buildin_source_location())) LogMyError("Just a test);

Video voice quality is not good.

NIce

Very useful. Seems like it’s far from zero cost. Does noexcept get used much in (semi) realtime systems?

First, thank you very much for the great lecture! I have a question: so we use integral_constant<bool, true> type, but isn't it possible somehow provide only value, i.e., for example `true`? Because we know, right, that `true` (or `false`) are of type bool? So IMO, it will be more natural to find a way to provide only values. Maybe should we use function templates to be able to deduce type? But, on the other hand, if I am not mistaken, starting from c++17 classes also deduce type, so maybe somehow can we use this?

So, in line 13 it is written min(m, ts....); Does that mean that at each step we reduce number of params in ts by 1 and pass it to 'b' ? it is also a bit confusing for me where exactly to put '...' . For example, why it is wrong to write like this: template<typename T ... >

A default parameter on a function in the base class is still useful. It allows a no-argument call to have meaning throughout the class hierarchy. It seems like the real problem here is the compiler should not allow a different default value for the virtual function in a derived class.

Great

You can use #pragma pack to make members adjacent, but work with memory will be slower.

Wrong

Andrea 99% of the surface area of your video content is blank. And the most important parts of your video is in the top left corner which is only 1% of the area. Would you please on your next videos kind of focus on that 1%. Either make the font larger so that it kind of becomes the 50% of the video surface area. A lot of people with huge monitors make this mistake. We don't need to see the useless 99% of the blank area. For the people too comfortably see that 1% of the surface area they will need to buy large monitors same as you. So watching this video on a 15 inch PC monitor a tablet or a phone is basically useless because you cannot even Zoom in on TH-cam videos.

Didn't think about this before. The key is also that std::string s{"Hell\0o"}; is not the same as std::string s = "Hell\0o"s; .

binge watching the series

very insightful!

thanks interesting insights. It seems initializer lists are not designed to pass by reference. Two other cases that are maybe more optimal if you avoid lvalues... Use move (if you have a move ctor): UInit c{std::move(a), std::move(b)}; Use temporaries to make the init list. maybe more the original thinking behind the concept: Uinit d{Unit(), Unit()}; //default, default, init list

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.

Have you seen any downsides to doing this? Does it prevent some common code idiom? I wonder if this could be made into a general guideline.

great tip! thank you

I'll think about it

Great tip. Thanks a lot!

Is it the same with -O3? What does destructing an empty object mean? Would empty struct optimisation interfere here?

why C++ is so fucking cmplex XDD?

I don’t get it, the compiler can demonstrate that the body of the function will not be able to throw, so it will not contemplate calling terminate. So the code will be optimal in this case anyway. This video gives the opposite impression because it doesn’t say that all this will be optimized. I think the problem is when you say no except and you are calling a function that the compiler cannot demonstrate it cannot throw. In this case the compiled code generated will generate the call to terminate. I heard that there was an old argument in the committee and there was a faction (Abrahams?) that wanted plain UB for uncatched throwing inside noexcept and the other wanted a guaranteed call to terminate. The second faction won but there were some regrets afterwards.

Thank you. Are the contents of your videos also applicable to MSVC?