Great explanation. Thank you

I am adding cpp file as include. Is this bad approach?

If I'm not mistaken, this only helps speeding up compilation times due to the explicit template specialisation. Still, what other benefits do I get by splitting template declarations and definitions?

Thanks a lot for watching, folks! Don't forget to share any thoughts you might have on this (or anything else)! 🙏

CMake Deez nuts

Great video! One thing that bothered me a bit was usage of "<typename ClassT> to specify template parameter. The parameter has nothing to do with class, it could be just as easily called <typename T>, the word "class" gives a wrong impression, at least to me. Thanks!

@10:57 when we call DoSmth(number) i didn't expect the parameter type to be int&. Why is that, and not simply int? After all, it will be copied...

Universal Reference gang member Here, Scott Myers most loyal soldier.

An interesting fact is that forwarding (or universal) references were discovered and not designed in the language. They just happened to spring into existence following the rules of template deduction and reference collapsing. It's one of the many miracles of the language showing that when you design something right it gives more value than designer has originally anticipated. It's an example of 1+1 giving more than 2.

Great Video. In the future would love to see Map with Object of class as key and as value. Love the music at the end. Please, can I get the full song?

I thought you'd say FetchContent, but submodule it is 🥳🥳

still can't figure out on what paramterts to put to make it choose this function T&& forward(std::remove_reference_t<T>&& t) instead

I was not able to replicate the uninitialiazed variable problem in @22:00 it always showed 0.0000e+00

Thank you for walking through how this forwarding works, particularly the ampersand collapsing. I hadn't fully understood how forwarding works until you put it all together like that.

You have some of the best videos on C++. I would love if after your "C++ basics" lessons that are happening, you could move to a more specialized subject. I see you have a PhD in computer vision, so that would be a cool subject to tackle in C++ (as a lot of tutorials use Python)

I find it better to understand if I read `&&` as `owned` or `owned_value`. #define owned && So the difference between `int` and `int owned` is the ownership.

Hey everyone. How did you find this video? Too long? Or short? Too complicated? Or rather too dumbed down? I need your feedback to make sure I’m getting better. So… what do you think? 🙏

My bet is: //2 //1 //3 //4 and 0 2 1 1

Can i also ask HTML or is it only C++?

VERY USEFULL!!! thanks for making learning fun!

Hi, I seem to forget small details like flags -c to not use linker etc. How to remember them?

What if we make header-only libraries instead.

Template meta programming with (partial) specialization is such a wildly different language than to "regular" C++. And it's such an incredibly deep rabbit hole. Interestingly enough, my knowledge about this topic really helped to understand Haskell a lot better during the semester it has been taught in. The signature pattern matching in partial specializations is almost identical to how Haskell functions are overloaded for their use cases. C++ really helps to become a better programmer, because it exposes the user to a lot more concepts than certain other languages that deem certain mechanisms to low-level or dangerous to be exposed to the programmer. But seeing how C++ was helpful for such an unrelated language with very different paradigms was just wild. :D

Nice T-short, man!

Sir. You Can Make A Video C++ Virtual Tabes Dynamic Linking How Works. With assembly.

BRUH. The universe might actually be alive. I have been struggling to understand templates and was a bit sad that you didn't drop a video on them. Now here you are. FTW.

That pretty much helpful and so easy to understand, thank you!

Cmake is absolute dogshit

Does this code at the end of each test run attempt to update submodules? Will this slow down the testing process if tests are run frequently?

Hi Igor, I am using CMAKE 3.16, when I tried the above I am getting a message stating that no tests found. How to resolve this?

Really great video and I love how much you went through in such a short amount of time. I was messing around with code to produce the two problems with template specializations and I found some interesting behavior I was wondering if you could shed some light on. For the record, I was using C++23 and Clang. The code I tested first for the problem that template's will never match reference types unless they are explicitely specified worked exactly the way you showed. However, I tried the Dimov/Abrahams problem using an Object pointer instead of an int pointer becuase I had created an object class for testing the previous example. Everything worked like I observed in your video until I tried changing the specialization to a function overload. My code still picked the template-function overload instead of the function overload! This was really confusing to me since I thought regular functions were always preferred over templates. I even tried moving the functions around, but no order I put them in changed the result. This stumpted me to no end, I tried the same example with an int and it worked just like you said it would! It seems the rules for templates are different for object pointers for some reason? I then thought that maybe the fact that I had these functions in a header file I was including was contributing to the problem because of course they were marked inline when necessary, so I tried in my main file and I got exactly the same behavior. This actually only ended up confusing me more because I encountered more strange behavior I wasn't expecting regarding the namespace from my header file. As usual, I put the namespace name in front of all my function calls since I didn't declare that I was using that namespace. CLion said that the namespace name wasn't necessary on the function calls where I specifcally passed an object or the address of an object, but it was necessary on my function calls where I was passing in an int or the address of an int. I then tried running my code and lo and behold I got errors when removing the namespace on my primitive function calls but I didn't when I did it for my object calls! I have absolutely no idea what was going on here and I would love an answer. It got weirder yet again because I had functions with the same name in both my main file and my header file, but I didn't get an error when omiting the namespace specifically on the calls where I was passing an object or the address of an object, which was strange because I thought there would have been a name conflict, but even worse, C++ actually picked the function from the header file in a different namespace instead of the one in the current namespace! I've seen some bizarre things in C++, but this is one of the most bizarre and I'm completely lost. I had to use the global-namespace specifier to get C++ to choose the function from it's current namespace which didn't make any sense. Even weirder still, this was only a problem when I called the function with an object. When I called the function with the object's address, the correct one was picked! I know you're probably busy, but I would love it if you could take the time to answer or direct me to a video explaining it if you know of one! Here is the link: godbolt.org/z/sdGsWra8G.

Great gratitude from 1 course student!

Thanks a lot for your tutorial! It's very clear.

Tenary operator is challenging for me.

Why can't I subscribe second or third time 😅 Great video!

Great video - thanks. But - the manual editing of the CMakeCache.txt appears to break what I have learned: "don't modify automatically generated files". Why does this not apply here?

I am a simple man. I see a new video from `Code for yourself`, I hit the thumb up button.

19:21 The explicit specialization is called in this case. As you mentioned, overload resolution, irrespective of where (and whether) the explicit specialization is declared, chooses `void Process(T*)` as a better match when calling `Process(pointer)`. Now, when the explicit specialization is declared *above* `void Process(T*)` it specializes `void Process(T)`, so the chosen template `void Process(T*)` doesn't have any explicit specializations and hence is (implicitly) instantiated from the template itself to form the (instantiated) specialization `void Process<int>(int*)`. When the explicit specialization is declared *below*, though, both templates are seen from it and both can deduce their T from the specialization, thus the ambiguity of which of the templates is actually being specialized is, per [temp.deduct.decl#2], resolved by partial ordering defined in [temp.func.order] and [temp.deduct.partial], i.e., a _more-specialized_ function template is preferred. In our case, `void Process(T*)` is more specialized than `void Process(T)` because `T` in `void Process(T)` can be deduced from `U1*` in `void Process(U1*)` while `T` in `void Process(T*)` can't be deduced from `U2` in `void Process(U2)`, where U1 and U2 are some unique synthesized types. Thus, this time it is `void Process(T*)` that is being specialized by our explicit specialization (resulting in specialization `void Process<int>(int*)` being explicit, not instantiated), so when `void Process(T*)` is chosen by overload resolution, its specialization is defined as we intended.

I wonder why statically typed language like C++ is so messed up with unnecessary features just because to look like dynamically typed ... What is the gain of templates because not readability and clearness for sure? Cheers!

of course <typename ...> is correct 😅

As usual nice and concise explanation of a complex C++ topic. Templates are possibly the language feature with the most time spent on teaching them. I don't know of any other topic that so useful and at the same time so full of corner cases, exceptions and nuances than templates and template metaprogramming. One thing that is interesting to mention is the ability to "disable" a template specialization when substitution for the template arguments is not possible, also known as SFINAE. Although, it is mostly being replaced by concepts since C++20. Maybe in a future video you could mention about concepts and how they affect the overloading rules when choosing the correct template specialization.

Pretty good explained. Considering other videos now.. (Not robot btw :) )

Hey everybody. This video took _a while_ to plan and record. Please comment if anything is unclear or, on the contrary, if you liked some explanation. Hope there won't be too many mistakes. 😅 Also, if you like what I do - smash that "Super Thanks" button 😉

That clip of cat failing to jump is exact visual representation of me running my code! 🤣🤣

cxx_setup is essentially working like a wrapper for our project (or rather library), right? It's sort of just separating some of the boilerplate stuff from the core of our code?

Now I'm trying to draw a 100x100 of the same cat image into the terminal but it gets too big in the terminal. How can I solve this? I cannot even draw original 360x400 in the terminal.

Very clear. I am using your lessons to complete the homneworks from the 2020 c++ course from Bonn Uni with professors Stachniss and Vizzo. Honestly without your lectures I would be lost. Huge thanks!

Маєш файну футболку

Maybe the "helpful compiler" should not be so helpful. 😂

how to do gtest and fuzztest. can you make tutorial from basic.