std::move and static_cast<&&>

Do I understand right, if I call std::move() with a temporary object, like std::move(A()) or std::move(int), it returns a reference to free memory?

As I know, if T&& or const T& assigns to rvalue or prvalue, it creates an object in memory and continues the life-time of the object while the reference is not destroyed? Does a second assign to a reference continue the life-time of the object?

Also, if I call, for example: int x; static_cast<int&&>(x), as I know it is an xvalue statement (reference), but what happens with the life-time of the object?

int&& foo() {
    int n = 5;
    return std::move(n);
}

foo(); // can second rvalue reference continue life of object while exist ref to object?
int x = 0;

static_cast<int&&>(x); // what happens with life time of object? or
static_cast<const int&>(x);

std::move(0); // will it return free memory? or
std::move(std::string("hello, world!"));

I'm just a beginner, and I would appreciate it if you could correct me if I make any mistakes.

The lifetime of an object is determined when the object is created and never changes after that. There is nothing you can do to an already-existing object that will cause its lifetime to change.

For your specific examples:

int&& foo() {
    int n = 5;
    return std::move(n);
}

foo returns a dangling reference. The lifetime of n ends when foo returns. Since foo returns a reference to n, and n's lifetime has ended, any read or write to the reference returned by foo will result in undefined behavior.

int x = 0;

static_cast<int&&>(x);
static_cast<const int&>(x);

These casts do nothing. Even if the result was assigned to another variable, they would have no effect on the lifetime of x.

std::move(0);
std::move(std::string("hello, world!"));

These both return dangling references. 0 and std::string("hello, world!") both create temporary objects. Reference lifetime extension would extend their lifetimes to the lifetimes of std::move's argument (since they are bound to that reference immediately at the moment they're created), but that argument's lifetime is shorter than that of the temporary objects anyway.

Some of your confusion seems to come from the so-called "reference lifetime extension" feature of C++. This does not, however, extend the lifetime of existing objects. It can only extend the lifetime of an object as it is being created.

If a temporary object is bound to a reference immediately upon creation then that temporary object's lifetime is extended to the lifetime of the reference.

That is, reference lifetime extension applies in all of the following cases:

// Here the string literal "Hello World" is converted to a to a temporary std::string
// which has its lifetime extended to the lifetime of foo
const std::string& foo = "Hello World";

// Here the return value of func is a temporary int object
// which has its lifetime extended to that of i
int func() { return 42; }
const int& i = func();

Reference lifetime extension does not apply in these situations:

// The temporary object created by the int literal 42 does not have
// its lifetime extended to that of i because it is not bound to i
// at the moment of its creation.
const int& func() { return 42; }
const int& i = func();

// The lifetime of the temporary std::string object created from the
// string literal "some string" does not get extended to the lifetime
// of f.member_ref because it is not bound to member_ref at the moment
// of its creation
struct Foo
{
    const std::string& member_ref;
    Foo(const std::string& s) : member_ref(s) {}
};
Foo f("some string");

</details>



# 答案2
**得分**: 1

我认为混淆是因为```std::move()```不移动任何东西。它只是一种类型转换。它完全不参与内存管理。

如果你有一个函数利用其参数是右值引用的事实来执行本应不安全的操作（比如使参数无效），编译器将保护你免受使用左值调用这样的函数。然而，如果你想使用左值调用这样的函数，知道你的变量可能会失效，```std::move()```会将其转换为右值，以便你可以调用该函数。

然而，可能使参数无效的是函数本身，而不是```std::move```。```std::move```只是使调用这样一个函数成为可能。

<details>
<summary>英文:</summary>

I think the confusion is because ```std::move()``` doesn&#39;t move anything.  It is only a typecast.  It doesn&#39;t participate in memory management at all.

If you have a function that takes advantage of the fact that its argument is an rvalue reference to do what would otherwise be unsafe (like invalidating the argument), the compiler will protect you from calling such a function with an lvalue.  If, however, you *want* to call such a function with an lvalue, knowing that your variable may be invalidated, ```std::move()``` casts it to an rvalue so you can call the function.

It&#39;s the function, however, not the ```std::move```, that potentially the invalidates the argument.  The ```std::move``` just makes it possible to call such a function.
    




</details>