RValue 引用、指针和复制构造函数

Question

考虑下面的代码：

int three() {
    return 3;
}

template <typename T>
class Foo {
private:
    T* ptr;

public:
    void bar(T& t) { ptr = new T(t); }
    void bar(const T& t) { ptr = new T(t); }
    void bar(T&& t) { (*ptr) = t; } // <--- Unsafe!
};

int main() {
    Foo<int> foo;

    int a = 3;
    const int b = 3;

    foo.bar(a); // <--- Calls Foo::bar(T& t)
    foo.bar(b); // <--- Calls Foo::bar(const T& t)
    foo.bar(three()); // <--- Calls Foo::bar(T&& t); Runs fine, but only if either of the other two are called first!

    return 0;
}

我的问题是，为什么第三个重载 Foo::bar(T&& t) 会使程序崩溃？这里到底发生了什么？函数返回后参数t是否会被销毁？

此外，我们假设模板参数 T 是一个非常大的对象，具有非常昂贵的复制构造函数。有没有办法使用 RValue 引用将其分配给 Foo::ptr ，而无需直接访问此指针并进行复制？

Answer 1

在这一行
void bar(T&& t) { (*ptr) = t; } } // <--- 不安全！
您可以取消引用未初始化的指针。这是未定义的行为。
您必须首先调用 bar 的其他两个版本之一，因为您需要为对象创建内存。
所以我会这样做 ptr = new T(std::move(t));。
如果您的类型 T 支持移动，则将调用移动构造函数。

更新

我会建议类似的事情。不确定您是否需要 foo 中的指针类型：

template <typename T>
class Foo {
private:
    T obj;

public:
    void bar(T& t) { obj = t; } // assignment
    void bar(const T& t) { obj = t; } // assignment
    void bar(T&& t) { obj = std::move(t); } // move assign
};

这将避免内存泄漏，这对于您的方法来说也很容易。
如果你确实需要你的 foo 类中的指针，怎么样：

template <typename T>
class Foo {
private:
    T* ptr;

public:
    Foo():ptr(nullptr){}
    ~Foo(){delete ptr;}
    void bar(T& t) { 
        if(ptr)
            (*ptr) = t;
        else
            ptr = new T(t);
    }
    void bar(const T& t) { 
        if(ptr)
            (*ptr) = t;
        else
            ptr = new T(t);
    }
    void bar(T&& t) { 
        if(ptr)
            (*ptr) = std::move(t);
        else
            ptr = new T(std::move(t));
    } 
};

Answer 2

该代码没有理由失败。 ptr 将指向先前调用 bar 创建的现有 int 对象，第三次重载只会将新值分配给该对象。

但是，如果您这样做：

int main() {
    Foo<int> foo;

    int a = 3;
    const int b = 3;
    foo.bar(three()); // <--- UB

    return 0;
}

foo.bar(two()); 行将具有未定义的行为（这并不意味着任何异常），因为 ptr 不会是指向 int 对象的有效指针。

Answer 3

假设您仅调用了foo.bar(三());而没有其他两个调用：

您为什么认为这可行？您的代码本质上与此相同：

int * p;
*p = 3;

这是未定义的行为，因为 p 没有指向 int 类型的有效变量。

Answer 4

“不安全”的事情是，在分配给 ptr 一个新对象之前，您应该担心 ptr 实际指向的对象的命运。

foo.bar(three()); 

是不安全的，因为你必须在调用它之前授予 ptr 实际上指向某个东西。在你的例子中，它指向由 foo.bar(b); 创建的内容

，但是 foobar(b) 使 ptr 指向一个新的对象忘记了由 foobar(a) 创建的对象

更合适的代码可以是

template<class T>
class Foo
{
    T* p;
public:
    Foo() :p() {}
    ~Foo() { delete p; }

    void bar(T& t) { delete p; ptr = new T(t); }
    void bar(const T& t) { delete p; ptr = new T(t); }
    void bar(T&& t) 
    { 
        if(!ptr) ptr = new T(std::move(t));
        else (*ptr) = std::move(t); 
    } 
}

；