Видео

I’m not entirely sure which one I used back then but I have mostly converged on using Fira Code everywhere now.

@@bsdooby thanks! I think it makes sense to teach them as separate concepts altogether

Thanks a lot for the compliments! 😌

@@Pedro-jj7gp that’s just the way it usually is on most modern systems: any pointer is 8 bytes. In the end this has to do with being able to address enough places in the memory if this makes any sense. That being said, other systems could theoretically have it be smaller or larger. Does this answer your question?

@@CodeForYourself It does, but I'm a bit confused as I was watching some other videos about vtables and they showed the vpointer taking up 4 bytes... I guess it could just be on that system.

@@Pedro-jj7gp it might be. But you can always check it on your system too. I’ve only ever seen 8-byte pointers on every system apart from really non-standard embedded boards. 🤷‍♂️

@@CodeForYourself Yup, you're right! I just checked using sizeof() both for a regular int* and a vpointer using reinterpret_cast<int*>() and both are 8 bytes. The video in question was 12 years old, maybe it was a 32-bit machine

@@Pedro-jj7gp sounds like a 32 bit system indeed. Glad that it makes sense now 👌

@@SystemSigma_ thanks! I actually put static polymorphism before this video, it’s right along a series of videos about templates: ruclips.net/video/1Mrt1NM3KnI/видео.html Still not the most modern thing but necessary to understand concepts down the line I believe. I also wanted to give an overview eventually of how to do the same things using both dynamic and static polymorphism on some concrete examples. But for that people need to be familiar with both. Does this make any sense?

@@CodeForYourself It does indeed. I meant that modern c++ features (especially type traits) are really useful for making more robust static polymorphic code. Maybe instead of going too generic with topics, restricting the features scope may be more interesting for experienced viewers.

@@SystemSigma_ I agree that a more in-depth look would suit experienced folk better. My aim here, however, is to fill in the complete playlist that would tailor to somebody who knows nothing about C++ and guides them gently through all the main topics, providing the "why" for using what they learn along with enough information to dig deeper. Please see here for the full list to date: github.com/cpp-for-yourself/lectures-and-homeworks Maybe one day, I will finish the basic course and have some time to dig more in-depth into certain things. That being said, I feel that there is plenty of that type of content on RUclips already, while the comprehensive courses that I've seen all fell a bit short of what I wanted to achieve here. But we'll see if my course is going to be helpful to anybody 😅

@@SystemSigma_ oh, and just in case you have not seen already, I _do_ talk about type traits a bit more in-depth here: ruclips.net/video/IQ62tA51Vag/видео.html

@@McDonaldIbekwe ok, so there is one video on testing that I did before but it is not in-depth. As for coroutines I would have to use them in some real projects to be able to speak confidently about best practices that relate to them unfortunately. 🤷‍♂️ I will try to squeeze some multithreading in though at some point but I can’t say when just now 🤷‍♂️

Yes, you are totally right, but I much prefer to be explicit rather than implicit. My logic is that it is not a big deal to type one more word but it allows us to not think about which inheritance is going to be picked by the compiler implicitly should we omit that “public”. Does this logic make sense?

Дякую! Радий, що сподобалось! Подивимось, взагалі план був про це розказати, але це така велика тема і в ній так багато чого відбувається, що я не впевнений що зможу її просто і добре пояснити. Але вона у мене в планах. 👍

Yeah, I thought of fitting to the standard UML style but then left it at that considering that the tools I used for creating the visuals did not have a non-filled arrow 😅

Thanks! I’m really happy that that move clicked. It was a long video so I wanted to end at one consistent example that would be relatively close to real life. 🙏

Thanks for your support and such a trust in me 🙏 But feel free to revise once watched 😉

true words

@@GeorgiosMATZARAPIS thanks man 🙌

@@akshaypratap4123 that’s not how I think I am usually perceived at all. Especially when I’m coding. 😅

@@rishiniranjan1746 thanks! This means so much to me! 🙌

@@BISONBOT94 awesome! Glad I could help out! 🙏

@@UvUtkarsh generally the code is written in such a way that as long as the provided types follow some form of an interface they should work. They also use traits and partially specialize classes based on what those traits tell about the provided type. I might do an in-depth look into this later if there is interest

There is an example of this towards the end of the video. Does that answer your question? Or should I give a better example? How can I make it better?

@@isfandyar3937 also, I cover this extensively in this video: Why use templates in modern C++ ruclips.net/video/1Mrt1NM3KnI/видео.html

Glad you liked it! 🙏

I guess you're right to a degree but there is more to it. Explicit template instantiation (different from specialization) does indeed help the compile times. It helps because without it, the code would live in header files and so would be copied to any translation unit that includes that header, leading to the compiler needing to compile all of those instances on their own. If we put the code into a source file (and for that we need an explicit template instantiation) we will only compile the code once and link it to the places where it is used instead. Does this make any sense? Now as to other benefits, one big downside of header-only libraries, apart from compilation times, is that all the implementation actually lives within the header files. Meaning that if we want to distribute our library to other people we essentially have to distribute source code. So in the end, we have a sort of a tradeoff, header-only libraries are quite simple to use but might lead to long compile times as well as to needing to show our source code to anybody using our library. I talk about this at length in the video about libraries here: ruclips.net/video/Lxo8ftglwXE/видео.htmlsi=JYNvd_2i6GLjfdvv

I'm perfectly aware of the standard benefits of splitting declaration and definition.. Still, for templates I really don't think it's worth the typing effort (if you're outside a smart ide) 😅 I guess the most valid point is only hiding the source code for distribution 😊

@SystemSigma_ sometimes the compile times are important too. Some years ago I added a couple of explicit instantiations in a code base to save about an hour compile time 😅 I think if we *know* the types we’re about to use, then I would go for a compiled library as opposed to a header only one. It works also as an additional check for my design to a degree 🤷‍♂️

@CodeForYourself yeah, I used it with quite a success in a few embedded projects, but, of course, every project is different so 🥲

@@SystemSigma_ yeah, I agree. 🙂‍↕️

Ok, I agree with you that ClassT doesn’t hit the mark. What I prefer doing generally (when I cannot use concepts) is to give the template parameters meaningful names. Considering that this function is very illustrative and doesn’t really have a proper purpose it is hard to pick such a template parameter name, meaning the one that actually makes sense. So here I picked the ClassT as a substitute but I agree that it is a bit stupid and if I would have thought longer about it I probably would have just used T here. Thanks for your comment!

For the win, my man

Unfortunately the answer to this comment is more complicated than I would like it to be. It has to do with how overload resolution is taken care of in C++, which is not trivial: en.cppreference.com/w/cpp/language/overload_resolution But the rule of thumb, at least the way I think about it, is that if we have a local object the compiler will prefer passing it by reference if an appropriate function overload exists. During this some implicit conversions can take place as well as some copies performed. My recommendation would be to write a simple example with some Foo function that has various overloads and see what the compiler does in each case to build more intuition. That being said if somebody who can explain it better stumbles upon this comment, I would like to find a nice and simple explanation for the future. 😅

@@CodeForYourself thank you, i really appreciate the answer, it surely provides a good starting point for me to try and understand this :) Keep up the great work, i discovered your channel with this video, and decided to start the whole course from the first lesson, even if I'm familiar with some of the basics of C++

@@francescobenacci6611 thanks for the kind words! Please mind that the first videos have a slightly different style from this one. I guess I converged to a style like this some time around the cmake video 😅

Welcome 😅

Yes, thanks for this comment! I believe the reason the name “universal reference” exists is just for that reason too! It came before the “forwarding reference” name was used in the standard. That being said, I don’t have the hard facts for this, so if somebody can point me in the right direction I would be immensely grateful 😉

Thanks 🙏 I’ll note the interest and we will see if I get to record something more about the map class. As for the music it is one of the RUclips samples. I’ll try to find the actual name tomorrow and send it your way.

Did you try the ones at the end of the lecture? Like pass a real temporary value into the forward function directly?

@@CodeForYourself oh lol, my bad. I mistakenly put real temporary value into doSmth instead of forward. lol, i'm so stupid. sorry for bothering u.

@ilovenirajan no worries at all! This is what learning is all about 👌 I make these mistakes all the time!

That is expected and is kind of the point that I was trying to make! Undefined behavior is like that: one cannot rely on it failing reliably. It will sometimes fail but then will also not fail at other time. Which makes it really frustrating 😬

@@CodeForYourself Thank you very much, Yes, I understand your point. I learned this the hard way once and now I have this uncontrollable urge of explicitly initializing everything (also usually this is the first thing I check when debugging) .

@en_x same on my side. It really pays great dividends! 😉

Thanks for the kind words! I have to admit that before recording the video I didn’t understand it fully either 😅 Well, I had a pretty good idea but then my intuition was wrong with respect to which forward overload would be called. 😅

Thanks 🙏 I keep playing with this idea. I come from a robotics background and we’ll see if I manage to make something out of it once I finish the C++ course here 😅

That’s an interesting idea, although I don’t like the use of macros here (what if you have a variable called owned in the code or smth) But apart from that it sounds fun. I’m not sure how I feel about it just yet as in my head a cope of a variable owns its memory too and can transfer it if we pass it through an std::move and some move assignment operator 🤔

​@@CodeForYourself Yes, I do not use in code but for explaining and understanding it is good. You can show a `int &&` and then show `int owned` to compare it in different contexed. For example: Saying `int &&` / `int owned` has more in common with `int`, than `int &`. Comparing && and & can be very confusing.

I don't know any way you could cover this topic with sufficient detail and be any shorter or less complicated. For me, it was just right.

Awesome! Thanks for the feedback and glad you liked it! 🙏

You should give more time to read and understand the examples. It's really nice to see you talking, but often you return from code to yourself way too quickly.

I don't have much use for std::forward (and had no idea how it works, and when to use it), so for me, it had the correct amount of detail.

@@taschenorakel totally makes sense. In this format I made a deliberate decision of keeping up with the pace to keep people a bit more engaged. My reasoning was that if people would really want to return and follow all the details they can always pause the video. I might convert all of this into a proper course on a different platform geared for just learning where I could maybe reduce rhetoric pace somewhat 🤔 Thoughts?

I’m not an expect in web dev, sorry 🤷‍♂️😁 For now it’s just C++. But once I’m done with the course we’ll see what comes next. That being said, it’s more likely to be Rust rather than anything web oriented 🤷‍♂️

Glad you like it! 🙏

@@CodeForYourself im exploring your vids and they are really cool 😎💪

@D1eg0_ really glad to hear that! Don’t forget to tell your friends! 😬

I wouldn’t bother. It’s really not such a big deal. One usually needs those flags only to figure out some weird thing happening. Once you see the linker errors you know you forgot the -c flag 😁

You mean like not ever use any other libraries?

​@@CodeForYourself okay I'm too much of a beginner. I think I understand the tradeoffs of different types of libraries. Header only libs makes the devs life simple. But if you want to hide the implementation then they wont work.

@@ChimiChanga1337 yes, you are exactly right! Also, header only libraries, when we have many of them, make compilation waaay too slow. With compiler libraries we are able to often compile them once and link all over the place. Does this make sense?

@@CodeForYourself Yes, I understand now. I really want to thank you again for this course!

@@ChimiChanga1337 my pleasure and I'm really happy that you like it! 🙏

Thanks for sharing! Did not think of this parallel! I have only played a little with functional language but yes, the recursiveness of template meta programming I guess is what makes the experiences similar.

I came back to c++ after spending some time with ocaml, rust, and idris, and everything was so much easier. This template stuff makes a lot more sense now and these videos are really good

@harleyspeedthrust4013 thank you so much! Hope you keep enjoying the videos coming next! 🙌

Thanks, Dima 😉

Not sure I want to include assembly in that video but otherwise the vtable video is planned already! 😉

@@CodeForYourself Just Waiting 🙋

Will try my best to make it as soon as I can 👌

Hope it helps 😅

While it has its quirks, this is probably too strong of a statement 🤷‍♂️

Thanks for the question! The update code is only run at the cmake configuration stage. So it is not run when the tests are run. Does this make sense?

Yeah, that’s a bit of a limitation. There was another comment under this video where we come up with a solution. Does that solution work for you?

@@CodeForYourself where is that test folder is mapped? I couldn't find it.

@whac-a-robot8623 it should be just the build folder itself. So you have to change the directory into that build folder and run the cmake command from there. If that doesn’t work out I’ll have a look more deeply into this.

@@CodeForYourself ok will check and let you know

@@CodeForYourself I understood it now. For quick reference for others you putting my solution here. Command 1 : cd build . Command 2 : GTEST_COLOR=1 ctest --output-on-failure -j12. Thank you for the support.

Sounds interesting. I’d like to give it a go. Can I ask you to setup a small reproducer on compiler explorer and share the link here?

@@CodeForYourself I just realized today that RUclips deleted my reply because I guess it thought the link was spam. I'll try to do my best to get it to go through. I can't give you the full link, but if you go to the normal url for Compiler Explorer, it's a '/z/' then sdGsWra8G. Let me know if that works! Thank you for taking the time!

@@CodeForYourself I'm sorry it took me so long to respond! I thought I had, but it seems RUclips won't let me reply with the link. It actually kept deleting my reply! I just edited my original comment to include the link at the bottom. Thank you, again, for taking the time!

@@Awesomekid2283 thanks a lot. Got it. Will have a look soon!

@@Awesomekid2283 Ok, I've looked into your example and see a couple of issues that could cause the behavior you describe. First of all, your functions are all `inline` in the header. Which means that they already have all of their definitions. You don't need to (and generally cannot, but see the next issue point) redefine such `inline` functions in the cpp file. You are only able to do it because of the namespaces that you use. Which brings us to the second point. Second, you have different namespaces in the header file and the source file. All of the functions in the header file are in the `templates` namespace, while all of the functions in the cpp file are in the global namespace. Now what happens is this: the functions in the header file are fully defined. The functions in the cpp file *do not define previously declared functions, they define new functions in the global namespace*. This causes all of the issues that you experience. Does this make sense? If you try to add the namespace `templates` in your cpp file, you will get quite a few "redefinition" errors during the compilation. I would generally recommend to try to simplify your testing setups. I do it myself. If I want to make sure that I understand a certain concept, like template specialization, I build up a *minimal* example - as small as I can, to make sure I'm only testing what I wanted to. In your case, you have at least three things going on in the same time - header/source file separation, namespaces and then template specialization/overloading. Separating these into separate small examples lets us learn them more easily.