Move Semantics in C++
Vložit
- čas přidán 11. 07. 2024
- The first 1000 people who click the link in the description will get 2 free months of Skillshare Premium: skl.sh/thechernoproject8
Patreon ► / thecherno
Instagram ► / thecherno
Twitter ► / thecherno
Discord ► thecherno.com/discord
Series Playlist ► thecherno.com/cpp
This video is sponsored by Skillshare.
Hope you all enjoyed the video! This is just the beginning of the Move Semantics Saga™, still to come is std::move, the move assignment operator, and more! Thanks for watching! ❤️
P.S. RELAX GUYS THE PS5 PART 2 VIDEO IS COMING TOMORROW
Do you have your own personal library of functions, classes, namespaces, etc? My professor told me that it's important for programmers to have their own tools which make their own methods easier.
ok
Excuse me, I know this is out of the point, but, do you know a way to turn off auto save in Visual Studio Community 2019?
Thanks for starting with Move Semantics.. looking forward for more about this..👍
Can you make a video about the rule of 3 and the rule of 5 and how to implement them properly?
In case anyone is wondering why there is only one "Destroyed" line being printed on Cherno's terminal, remember that his program halts due to "std::cin.get()". Once he presses Enter, he should see the other "Destroyed" message.
Reason for two destroys: 1 where the hollow object is destroyed + 1 where the actual heap memory is deallocated.
Hope this saves time for someone and helps!
Thanks, I was getting two "Destroyed" and was like what the heck ;). Then I debugged it and the first one is destroying object with size of 0 and data as null, so I actually deduced this somehow myself too...
Thanks! I was wondering exactly that. Saved me some googling
yeah I was wondering! saved me some time!
Bless your soul...
it helps! should read the comment first before figuring it out myself🤣
I owe you a huge thank you ! I've been trying to understand what are lvalue and rvalue for quite a long time, and an even longer time for what the move semantic was all about, and I've finally understand it with your video.
I'm in a big learning phase right now, and your channel is an awesome way to improve myself. Thanks for the good work !
Thank you for this video! This is one of my favorite series on CZcams and this is a topic that can be quite confusing but you simplified it beautifully. Great job and keep up the good work
Thank you so much for this move semantic vid. This has been wildly helpful to me today. Love your channel, your C++ playlist is by far my favorite of all C++ content.
8:24 noexcept is important for performance reasons. In a talk I saw, the example presented was 60% faster using noexcept because of the nature of push_back operation in std::vector. So keep that in mind!
what's the talk you saw? :)
@@IndyR0ck Probably this one: Back to Basics: Move Semantics (part 1 of 2) - Klaus Iglberger - CppCon 2019
@@torstein5 thx!
My first professional language was C++, and I moved from it in 1998 when I started working in Internet / Social media. I've moved back to writing low level code on hardware again, and I've been enjoying your videos a great deal. C++ has come a long way, and you've made my transition back a very easy one.
BTW, I love the Hazel stuff too. Last time I worked with 3D graphics was when bsp trees were a new thing (and "fingering John Carmack" was something that was regularly done...) Fun to see how far that has all gone. I'm not doing any graphics right now, but fascinated with amount of forward movement in the field over the past 25 years.
Pointing fingers at sir John Carmack? Sounds like the DOS days to me!
I'm sorry I'm asking this _TWO_ years later, but in your opinion, how fast is C++ at evolving?
It is often called an ever-evolving language, and especially with us getting a new standard every third year, I, a beginner, feels the same way.
Thoughts?
I invite other veterans to answer, too!
Holy shit. I thought I knew things. I don’t know anything. This channel has been such a blessing. Instant sub.
That video really came, when i needed it thanks Cherno
Founding this channel is a god damn blessing for me. Why did I not know about you earlier? Probably spent my whole life of luck on this.
Thank you so much fir being so thorough with your explanations! :)
m_Data = new char[m_Size] should be freed with delete [ ] m_Data; and not delete m_Data;
It should also be m_Size + 1 when allocating for the null terminator
@@gideonunger7284 Not necessarily. You don't need to store a null terminator if you know your string's size. Though it can be useful with C style string functions.
But he should've used delete[] or maybe even allocated with a unique_ptr instead.
That is good advice in general, however in this case is not necessary because the destructor of char is a no-operation. In this specific scenario is not necessary to call the destructor of every object in the array by calling delete[].
@@Spirrwell yes sure if you don't work with any c string functions or pass that pointer to the outside it's fine. But it's still dangerous in c++ since the assumption of a char* is that it's null terminated. Rust doesn't use null termination but there it's the standard of the language so it's not a problem anywhere
@@gideonunger7284 It's already dangerous to assume the const char* passed to strlen() will be null terminated. In C++ a compiler might add a null character to such values in double quotes but a C compiler won't do that implicitly which makes sense because you will know the length of a constant array of chars in your code already as developer.
Great explanation! BTW your hair looks great here
This makes way more sense than what was being taught to me, where we just pushed multiple of the same object into a vector with different values (i.e. vec.push_back(Move{10})... vec.push_back(Move{n})). Sure it works, but doesn't help with visualizing the need to use a move constructor or semantics. This video helps so much, it just clicked instantly after watching this!
OMG! Ever since your view_string video, I've been obsessed with making my own string_view! After this video I was able to mimic some functionality via referencing the same memory! With some extra steps I can prevent writing! Thanks so much!!
Need that part 2 reaction video bruh. U be preaching facts and I be feeling that. Keep up the good work my guy. Just run that reaction video for ya boy. You’re killing me Smalls
This C++ series will never run out of topics to make a video about :)
I've got too many requests what to cover in next videos.
For example Multithreading: it would take forever to make videos about threads, locks, lock-free synchronization, fibers, coroutines etc.
This didn't aged well...
@@godnyx117 Oh yeah I expected this series to cover more advanced topics but had to do my own research on the topic instead.
Still a very great series and the best C++ series there is on CZcams!
really love your videos and i have learn a lot things from them
This is amazing! Thanks!
Great video, very clear!
Man I was waiting for this from ages 😭😭😭😭, FINALLY Thanks Chernikov 😄
This helped a lot, thank you!
Wow, naming a parameter "string" is quite... courageous:-)
Unless you're using namespace std, it doesn't really matter.
@Artem Katerynych
#include
using namespace std;
string string(string string) {
string string = string;
}
int main() {
string string = “string”;
string(string);
}
@@ianpan0102 Using namespace std is a cardinal sin anyway
@@unsafecast3636 Bruh Bruh(Bruh);
@@unsafecast3636 god
I really enjoyed your video, thanks.
Wow❤️ simplified to the core
Excelent explanation, thank you
entertaining while *learning*, love it
Great you solved one headache for me, thanks
Just found you channel and watched almost all of your c++ videos and some of your game engine series. Awesome job and thank you! Wanted to ask how you feel about rust compared to c++ and if you have had any experience with rust at all?
THANK YOU MY FRIEND! YOU JUST SAVED MY SEMESTER :D
Yesss, I've been waiting for this, THANK YOU :)
Will you make a video on Return Value Optimization in the future? I don't really get that topic, my professors aren't good at explaining, but you are
Thank you!
I learned so much about it but still dont know how to use it. So happy to see that you do a video on it as you always go very deep into these topics.
Your videos always explain everything better 👍...
Nice example
I KISS YOUR EYES! I didnt unterstand it with my book, but then i found you. R Value Refenrences and Move Semantics are very usefull
Man... God bless you! :)
u give a human touch to a very dry and difficult topic , very helpfull
Hello Cherno, please keep uploading new features of C++ 11/14/17/20.
Your content is great.
Great video, I always look forward to your stuff.
That said, at 0:53 isn't that what references (pointers) are for? You don't have to copy a value to/from a function if you just pass/receive a pointer?
Still working as of today, ty!
Also, I believe any time the compiler can use Return Value Optimization do not try to use move semantics for return values. RVO will be more efficient.
Thank you so much Cherno!! You're seriously the best 😊
Ayo my g we respect your regular content...but we want that that ps5 part 2
It's worth noting that we need to make the moved-from string "hollow" because its original constructor will still fire. In essence, a moved-from object can have multiple instances of its destructor being fired. This, as you can imagine, is rather inefficient. The alternative is what's called a "destructive move," but the design committee of the language couldn't figure out a way to make that fit with the existing object model. For the curious, you can look up Howard Hinnant's and Sean Parent's posts on this matter.
Thank you for the free 2 months of skill share ;D
4:40 should be delete [ ]
He should've tested it on PVS-Studio to see if it can detect the memory leak.
what is the difference ?
@@abdallahrashed1947 "delete" destroys a dynamically allocated object and "delete[]" destroys a dynamically allocated array
@@TernaryM01 underrated comment lol
Very nice and excellent video!!! Tho I've got a small question: should we be usong "delete [ ] m_Data" in the destructor? Since it is created from "new [ ]"
Yes, the program needs to clean the continuous block of memory allocated to m_Data.
Less typing with "puts" (it adds '
"), so no need to use printf only to print non-formatted string with "
" at the end. Anyway great material Cherno.
Finally ... It's here. Thanks Cherno.
Next awaited .....
Regex
SFINAE
Random engines
You can do printf("%.*s
", (int)m_Size, m_Data); rather than that printf loop - it's easier, more efficient, and won't b0rk when you call it from multiple threads since the single call will happen under the stdout lock.
Yes the ps5 part 2 is coming this weekend, whose looking forward to that
So after attempting to learn move semantics/rvalue references for n times ( n >= 100) this finally clicked. Thanks, Cherno!
Should you use move with functions?
Let's say:
std::vector add( std::vector a, std::vector b) { ... }
and I need to use whatever is passed into a and b later, is it better to pass by reference or move? I know that anything moved shouldn't be used again, so is there a way to move back after the function is done? Like making the parameter a const move or something?
I ran some trials and move was faster than reference (is that true?) but it's pointless if it leads to undefined behavior.
Can someone please give this guy an award!
Hey Cherno, could you please make some videos on lock free programming and memory ordering as well? Thanks for all the great content so far.
Memory ordering is a very tricky subject.
This is freaking greatest explanations ever for move sementic with demo : this explains whats going on underneath actually!! And how move sementic helpful in performance
Hey, Cherno, the video after Static Analysis in C++ is now marked as private. Was that intentional? Or was it also on move semantics but now you're redoing it and thus removed the old one? Loving your content!
Good stuff
He finally did it
Dude loved the ps5 video, can't wait for the next part !!!
Ok my head is spinning now
Top class teacher for Cpp
well done explained
These videos are here to stay to help people even 5+ years from now 😨
Hi Cherno, you are just amazing.. Well described. But can you help me in finding out where I'm getting wrong, when I say we can do the work, you done in move constructor, in the copy constructor even in that constructor we only getting reference of the object, then what is the need to define separately!
Greate Video! Can you please do a series or at least a video to give an overview of how to get started with Authoritative Multiplayer Code with C++?
Excellent example with string!
What made you switch to printf over streams? Personally I always use fmtlib, and I can see that printf is quite similar, but why tho?
Literally just watched your lval rval video an hour ago. Good timing :)
Thank you, Cherno. For something like this, the code to look at as a text file would be worthwhile. How about it?
Do all containers in modern C++ have move constructors and move assignment operators by default? and if so how do you use them?
Great video! one comment though: When you heap-allocate an array you have to free it with 'delete[]' instead of 'delete'. Your code frees only the first element of the array.
Technically its UB with char* string literals
what really?
According to the standard, using delete instead of delete[] is UB. In practice, both delete and delete[] are simply forwarded to the libc function "free", and therefore end up behaving the same. Of course I an NOT advocating using delete instead od delete[], that would be terrible practice. But there isn't an implementation out there that only frees the first element. In fact there isn't a function you could use to only free the first element. Even realloc won't do that.
With `delete` instead of `delete[]`, the whole array gets freed, no problem so far, but only one destructor might be called: that of the first element. This doesn't matter in the case of a `char` array, but it can be relevant for more complex objects, which in turn might allocate their own memory (which would then have to be freed again).
@@Flinsch77 that is correct. Thanks for that
I don't think I've ever been so excited to watch a C++ video before xD. They should put you on Netflix Cherno! ;)
When you are running your code at 11:40, the compiler still choose the copy constructor over the move constructor. Would it work if you explicitly forbid your copy constructor to accept rvalues, by making the input parameter not const (line 15)?
Thanks for the great explanation. I just have a note, you are moving the curser a lot making it a bit difficult to follow. cheers
You should tell people about swap idiom in this Move Semantics Saga™
The way you added cast before bringing in std::move was really the way std::move should always be explained.
My goodness! I didn't know the last part...
Hey I want to ask a question about copy constructor that you have coded. In an example like this:
String first("The first string");
String second("The second string");
first = second;
Will the code above cause memory leak because of the copy constructor that you have written? The copy constructor allocates new memory all the time but it doesn't delete the old one if it's exist. @TheCherno
if we use the new[] operator for allocating memory for m_Data, shouldn't we use the delete[] operator in the Destructor, or am I missing something ?
You missed pointing out that if you have a true temporary it will also use the move constructor without needing ::std::move
I followed along and at the 11:50 mark, where you change the String&& cast to using std::move, the result is the copy constructor returns to being used. Any ideas why this could be?
Cherno, you could perfectly voice Mike Judge, several B&B characters including Butthead. Did anyone point that out? Quite good resemblance in this video!
Good stealth
You should explain the explicit std::move() call in entity ctor. If you look at the ctor of entity it already accepts rvalue so why explicit move if the signatures of entity ctor and string ctor match. Why is function overloading not working here all the way down?
Hi Cherno, Is move semantics just a shallow copy and setting other's pointers to null?
At 5:15, can you confirm, do we need the copy constructor because the default `String` constructor will only copy the `m_Data` pointer, but not its contents (as you mentioned in your Copy Constructor video)? I was a little confused at first because `String m_Name` in `Entity` is not a pointer.
any chance of a map/unordered_map, with hashing/compare function creation for custom key types tutorial?
im confused about following, when setting other.size =0 arent we also setting our copied data to 0 since we re pointing to the same value? Am I correct to assume that when we use the && function we should think about the variables as pointers instead of references in a sense that were purely assigning pointers now and arent changing the values directly, only the addresses.
I'm new to coding/programming. I started with JS and PHP. Along the way I learn OOP, and design patterns. Accidentally, I learn to understand Java and C++ syntax thanks to CZcams video suggestions like this. Thank you!😊
I have a question, when we are using std::string& and then assigning our data to that (means copying it) [myClass(std::string& str) : myStr(str) { }] CLion gives suggestion to use this [myClass(std::string str) : myStr { std::move(str) } { }]. Is there a reason?
What a colossal PITA
What was that syntax when he did Entity entity (String("Cherno"));
What function is String ()?
Sorry if my question is too obvious... still learning the basics.
What happens if in the move constructor, you cannot mutate the m_Data field of your temporary rvalue object?
For example, if the String class declares the m_Data field as "const char *const m_Data", then you wouldn't be allowed to assign nullptr to the rvalue object. Should we just avoid doing (sometype *const) in general in C++? Or is there a workaround for this?
Dat rubber duck water bottle
Some of the videos are really clear cut and understandable, but I must say that in this one I dropped the ball very quickly. In like 10 seconds there appeared 50 lines of code and multiple class with their methods, privates, publics, printf, memcpy, delete etc.
what is the meaning of String() = default? what is the " = default" do?
Fairly certain this conundrum was a chapter in Effective C++.
Please do an episode about explicityly defaulted constructors like String() = default
Move semantics is basically the same thing as what Patrick said from sponge-bob. Why don't we just move the bikini bottom. In other words, moving a large object without copying it. It would be a real pain to build a town, rebuild it somewhere else, and tear the old one down.
Thanks btw, your videos semantics and R/L values really helped me out a lot. Would have probably given up on my textbook if I hadn't seen this video.
The moment I realized how R and L values worked was when you mentioned the phrase "Location Value". All the rules suddenly clicked. I realized L values were like vacant houses for variables. When you assign 10 to x, you are assigning the value of 10 (an R value) to a memory location (l value). Reference variables allow you to sort of bend the rules a bit...