C ++ 11中的有效算术运算符重载

Question

I have a POD struct that has a number of members, and I would like to know the most efficient way in C++11 to implement its arithmetic operators.

This struct is meant to be used in place of primitives in a mathematical context; for example:

template<typename Double>
Double calcSomething(const Double& d0, const Double& d1, const Double& d2)
{
    return d0*d1 + 3*d2 - 6;
}

Where Double is either just a normal double , or is a POD struct with all the relevant overloaded operators:

struct MyDouble
{
    MyDouble(double a, double b) : _a(a), _b(b) {}
    double _a;
    double _b;
};
MyDouble operator+(const MyDouble& d0, const MyDouble& d1) 
{
    return MyDouble(d0._a + d1._a, d0._b + d1._b);
}

Is there a really nice, efficient way to implement this in C++11 using move constructors and rvalue references? Keep in mind that MyDouble could be a large POD struct (ie not just two doubles).

I would like to keep the discussion about structs that do not have pointers to heap-allocated memory.

Answer 1

If a struct doesn't own any other objects or resources, then move semantics and copy semantics are identical. Even a move constructor or move assignment operator needs to copy all data members to the target object. It just doesn't have to perform a deep copy, ie owned sub-objects are simply transferred to the target object, instead of being copied.

If your struct is truly huge, you can create a holder type which contains a pointer to a heap-allocated instance (using scoped_ptr, preferably). You can then support move on that holder type - actually, if you manage the actual instance with scoped_ptr, you'll get move support automatically, I think.