CODEWITHSUNDEEP
c++c++11
Raju
Raju

Reputation: 1169

Why std::move() is not stealing an int value?

std::move() is stealing the string value whereas not an int, please help me.

int main()
{
    int i = 50;
    string str = "Mahesh";        
    int j = std::move(i);
    string name = std::move(str);       
    std::cout <<"i: "<<i<<" J: "<<j <<std::endl;        
    std::cout <<"str: "<<str<<" name: "<<name <<std::endl;
    return 0;        
}

Output

i: 50 J: 50
str: name: Mahesh

Upvotes: -1

Views: 915

Answers (2)

Michael Kenzel
Michael Kenzel

Reputation: 15941

std::move() itself doesn't actually do any moving. It is simply used to indicate that an object may be moved from. The actual moving must be implemented for the respective types by a move constructor/move assignment operator.

std::move(x) returns an unnamed rvalue reference to x. rvalue references are really just like normal references. Their only purpose is simply to carry along the information about the "rvalue-ness" of the thing they refer to. When you then use the result of std::move() to initialize/assign to another object, overload resolution will pick a move constructor/move assignment operator if one exists. And that's it. That is literally all that std::move() does. However, the implementation of a move constructor/move assignment operator knows that the only way it could have been called is when the value passed to it is about to expire (otherwise, the copy constructor/copy assignment operator would have been called instead). It, thus, can safely "steal" the value rather than make a copy, whatever that may mean in the context of the particular type.

There is no general answer to the question what exactly it means to "steal" a value from an object. Whoever defines a type has to define whether it makes sense to move objects of this type and what exactly it means to do so (by declaring/defining the respective member functions). Built-in types don't have any special behavior defined for moving their values. So in the case of an int you just get what you get when you initialize an int with a reference to another int, which is a copy…

Upvotes: 1

Caleth
Caleth

Reputation: 62864

std::move is a cast to an rvalue reference. This can change overload resolution, particularly with regard to constructors.

int is a fundamental type, it doesn't have any constructors. The definition for int initialisation does not care about whether the expression is const, volatile, lvalue or rvalue. Thus the behaviour is a copy.

One reason this is the case is that there is no benefit to a (destructive) move. Another reason is that there is no such thing as an "empty" int, in the sense that there are "empty" std::strings, and "empty" std::unique_ptrs

Upvotes: 2

Related Questions