Your Move Constructor Is Ignored (C++ Betrayal)

Ajouté : 2026-05-11

[00:00:00]You're writing a move constructor to make your code faster. However, STL containers like std::vector still use your copy constructor because you forgot a single keyword, the noexcept keyword.

[00:00:12]Let me show you the problem that we have.

[00:00:29]So, you can see right here that I've created a basic class that manages its own resources that live on the heap, and because it does so and it has these new calls in both the constructor and the copy constructor, it also has to implement the delete constructor and the move constructor because of the rule of three.

[00:00:50]And you can see right here that the copy constructor takes up more time than the move constructor, so the copy constructor is less performant since you need to allocate a new resource on the heap in the copy constructor, but in the move constructor, you just copy over the old address.

[00:01:10]And that's why the move constructor is faster. So, if C++ can decide between the copy constructor and the move constructor, it would be better if it decided for the move constructor >> [snorts] >> since um that variant is way faster.

[00:01:28]So, let me now show you the problem that we have because I didn't add the noexcept keyword to the move constructor.

[00:01:43]So, you can see right here that we just created a basic vector of data objects, and we push back five data objects.

[00:01:52]What we would expect is to only get move calls.

[00:01:56]Why would we only get move calls? Well, let's think about this.

[00:02:01]Passing in an rvalue will result in the rvalue overload of the push_back function to be called, and that will move the um given argument into the place at the internal pointer of the vector class.

[00:02:20]Now, additionally, we will have some reallocations inside of the vector class whenever the size exceeds the capacity.

[00:02:29]However, those reallocations should also result in a move call since the objects at the old location won't be used anywhere else, and we can safely steal their resources.

[00:02:44]So, from an intuitive perspective, I would assume that the std::vector class will choose to use the move constructor for re- placing the old objects at the new location.

[00:03:03]Now, if we run this program, you can see right here that we're getting both moved calls. However, we're getting copied calls as well.

[00:03:12]The moved calls are created because of what we've previously already discovered.

[00:03:19]Um well, we're passing in an rvalue in here, and the rvalue overload of the push_back function is called, and that's why we're getting these moved calls.

[00:03:28]The copied calls, however, are a result of this reallocation happening, and the objects at the old place being copied over to the new place, even though the objects at the old place are immediately deleted afterwards.

[00:03:43]So, that doesn't make much sense. We should expect the std::vector class to only use moved calls, but it doesn't. And why is that? Because we didn't add the noexcept keyword.

[00:03:56]Now, if I rewrite this program and only add the noexcept keyword, and now once again run this, you can see right here that we're only getting moved calls.

[00:04:07]And that is the case because what the std::vector class is using under the hood isn't the std::move function, but rather the std::move_if_noexcept.

[00:04:20]So, it only moves the given object if the T class implements a move constructor, and that move constructor is marked as a noexcept constructor.

[00:04:37]So, you can see right here that the entire purpose of the move constructor is pretty much defeated if you don't add this noexcept keyword for certain STL containers. So, you can still use your move constructor in other places. However, when you're using your class inside of sequential STL containers, most of them use this move_if_noexcept function, and that's why it's necessary for you to add this noexcept keyword so that you can actually use the full power of your move constructor.

[00:05:17]I hope you learned something new from this, and if you did, make sure to leave a like and subscribe. And yeah, bye-bye.