Question

据我所知，添加移动语义的一个目的是通过调用特殊构造函数来复制“临时”对象来优化代码。例如，在this回答中，我们看到它可用于优化此类string a = x + y内容。因为x + y是一个rvalue表达式，所以我们只能复制指向字符串的指针和字符串的大小，而不是深度复制。但正如我们所知，现代编译器支持return value optimization，因此不使用移动语义，我们的代码根本不会调用复制构造函数。

为了证明这一点，我写了这段代码：

#include <iostream>

struct stuff
{
        int x;
        stuff(int x_):x(x_){}
        stuff(const stuff & g):x(g.x)
        {
                std::cout<<"copy"<<std::endl;
        }
};   
stuff operator+(const stuff& lhs,const stuff& rhs)
{
        stuff g(lhs.x+rhs.x);
        return g;
}
int main()
{
        stuff a(5),b(7);
        stuff c = a+b;
}

在VC ++ 2010中执行它并在优化模式下执行g ++后，我得到空输出。

它是什么样的优化，如果没有它，我的代码仍然可以更快地运行？你能解释一下我的理解错误吗？

Answer 1

移动语义不应被视为优化设备，即使它们可以这样使用。

如果您想要对象的副本（函数参数或返回值），那么RVO和copy elision将尽可能地完成工作。移动语义可以提供帮助，但比这更强大。

当您想要执行不同某事时，移动语义很方便，无论传递的对象是临时对象（然后绑定到右值引用）还是“标准”对象带有名字（所谓的 const lvalue ）。如果您想要例如窃取临时对象的资源，那么您需要移动语义（例如：您可以窃取std::unique_ptr指向的内容。

移动语义允许您从函数返回不可复制的对象，这是当前标准无法实现的。此外，不可复制的对象可以放在其他对象中，如果包含的对象是，那些对象将自动移动。

不可复制的对象很棒，因为它们不会强迫您实现容易出错的复制构造函数。很多时候，复制语义并没有真正意义，但移动语义确实如此（想一想）。

即使std::vector<T>不可复制，也可以使用移动T类。在处理不可复制的对象（例如，多态对象）时，std::unique_ptr类模板也是一个很好的工具。

Answer 2

经过一番挖掘后，我在Stroustrup's FAQ中找到了使用右值参考进行优化的优秀示例。

是的，交换功能：

    template<class T> 
void swap(T& a, T& b)   // "perfect swap" (almost)
{
    T tmp = move(a);    // could invalidate a
    a = move(b);        // could invalidate b
    b = move(tmp);      // could invalidate tmp
}

这将为任何类型的类型生成优化代码（假设它具有移动构造函数）。

编辑：此外，RVO无法优化此类内容（至少在我的编译器上）：

stuff func(const stuff& st)
{
    if(st.x>0)
    {
        stuff ret(2*st.x);
        return ret;
    }
    else
    {
        stuff ret2(-2*st.x);
        return ret2;
    }
}

此函数始终调用复制构造函数（使用VC ++检查）。如果我们的类可以更快地移动，那么使用移动构造函数我们将进行优化。

Answer 3

想象一下，你的东西是一个像堆一样分配内存的类，而且它有容量的概念。给它一个运算符+ =将几何增加容量。在C ++ 03中，这可能看起来像：

#include <iostream>
#include <algorithm>

struct stuff
{
    int size;
    int cap;

    stuff(int size_):size(size_)
    {
        cap = size;
        if (cap > 0)
            std::cout <<"allocating " << cap <<std::endl;
    }
    stuff(const stuff & g):size(g.size), cap(g.cap)
    {
        if (cap > 0)
            std::cout <<"allocating " << cap <<std::endl;
    }
    ~stuff()
    {
        if (cap > 0)
            std::cout << "deallocating " << cap << '\n';
    }

    stuff& operator+=(const stuff& y)
    {
        if (cap < size+y.size)
        {
            if (cap > 0)
                std::cout << "deallocating " << cap << '\n';
            cap = std::max(2*cap, size+y.size);
            std::cout <<"allocating " << cap <<std::endl;
        }
        size += y.size;
        return *this;
    }
};

stuff operator+(const stuff& lhs,const stuff& rhs)
{
    stuff g(lhs.size + rhs.size);
    return g;
}

另外想象一下你想要添加两件以上的东西：

int main()
{
    stuff a(11),b(9),c(7),d(5);
    std::cout << "start addition\n\n";
    stuff e = a+b+c+d;
    std::cout << "\nend addition\n";
}

对我来说，打印出来：

allocating 11
allocating 9
allocating 7
allocating 5
start addition

allocating 20
allocating 27
allocating 32
deallocating 27
deallocating 20

end addition
deallocating 32
deallocating 5
deallocating 7
deallocating 9
deallocating 11

我计算3个分配和2个解除分配来计算：

stuff e = a+b+c+d;

现在添加移动语义：

    stuff(stuff&& g):size(g.size), cap(g.cap)
    {
        g.cap = 0;
        g.size = 0;
    }

...

stuff operator+(stuff&& lhs,const stuff& rhs)
{
        return std::move(lhs += rhs);
}

再次跑步我得到：

allocating 11
allocating 9
allocating 7
allocating 5
start addition

allocating 20
deallocating 20
allocating 40

end addition
deallocating 40
deallocating 5
deallocating 7
deallocating 9
deallocating 11

我现在只有2次分配和1次解除分配。这转化为更快的代码。

Answer 4

在其他答案中有很多地方都有提及。

一个重要的一点是，当调整std::vector的大小时，它会将移动感知对象从旧内存位置移动到新内存位置而不是复制并销毁原始内容。

此外，右值引用允许可移动类型的概念，这是语义差异而不仅仅是优化。 {+ 1}}在C ++ 03中是不可能的，这就是为什么我们有abomination of auto_ptr。

Answer 5

仅仅因为现有优化已涵盖此特定情况并不意味着其他情况不存在，其中r值引用有用。

移动构造允许优化，即使从无法内联的函数返回临时值（可能是虚拟调用，也可以通过函数指针）。

Answer 6

您发布的示例仅采用const左值引用，因此显式不能将移动语义应用于它，因为那里没有单个右值引用。当您实现没有右值引用的类型时，移动语义如何使代码更快？

此外，您的代码已被RVO和NRVO涵盖。移动语义适用于远远超过这两者的情况。

Answer 7

这一行调用第一个构造函数。

stuff a(5),b(7);

使用显式公共左值引用调用Plus运算符。

stuff c = a + b;

在内部运算符重载方法中，您没有调用复制构造函数。同样，第一个构造函数只被调用。

stuff g(lhs.x+rhs.x);

使用RVO进行分配，因此无需复制。

不需要从返回的对象复制到'c'

stuff c = a+b;

由于没有std::cout引用，编译器会关注从未使用过的c值。然后，整个程序被剥离，导致一个空程序。

Answer 8

我能想到的另一个好例子。想象一下，你正在实现一个矩阵库并编写一个算法，该算法需要两个矩阵并输出另一个矩阵：

Matrix MyAlgorithm(Matrix U, Matrix V)
{
    Transform(U); //doesn't matter what this actually does, but it modifies U
    Transform(V);
    return U*V;
}

请注意，您不能通过const引用传递U和V，因为算法会调整它们。理论上你可以通过引用传递它们，但这看起来很粗糙，并使U和V处于某种中间状态（因为你调用Transform(U)），这对调用者可能没有任何意义，或者根本就没有任何数学意义，因为它只是内部算法转换之一。如果您只是按值传递代码并使用移动语义，如果您在调用此函数后不打算使用U和V，则代码看起来会更清晰：

Matrix u, v;
...
Matrix w = MyAlgorithm(u, v); //slow, but will preserve u and v
Matrix w = MyAlgorithm(move(u), move(v)); //fast, but will nullify u and v
Matrix w = MyAlgorithm(u, move(v)); //and you can even do this if you need one but not the other

如果我们已经拥有RVO，那么移动语义会提供什么优化？

8 个答案: