Как уменьшить избыточный код при добавлении нового C++ 0x rvalue перегрузки ссылочного оператора

Во-первых, я не понимаю, почему оператор + вообще изменяет аргументы (разве это типичная реализация неизменяемого двоичного дерева), поэтому не будет никакой разницы между ссылкой на r-значение и l-значение. Но давайте предположим, что поддеревья имеют указатель на родителя или что-то в этом роде.

Из показанного вами примера использования похоже, что существует неявное преобразование из double в tree. В этом случае ваши случаи "cast and forward" не нужны, компилятор найдет определенное пользователем преобразование.

Разве перегрузки без перемещения не создают новый экземпляр для перехода в новое дерево? Если да, то я думаю, что вы можете написать три из оставшихся четырех дел в качестве экспедиторов.

tree operator +(tree&& a, tree&& b); // core case
tree operator +(tree   a, tree   b) { return std::move(a) + std::move(b); }
tree operator +(tree   a, tree&& b) { return std::move(a) + std::move(b); }
tree operator +(tree&& a, tree   b) { return std::move(a) + std::move(b); }

Конечно, вы можете использовать макрос для создания трех (или семи) версий пересылки каждого оператора.

EDIT: если эти вызовы неоднозначны или разрешают рекурсию, как насчет:

tree add_core(tree&& a, tree&& b);
tree operator +(tree&& a, tree&& b) { return add_core(std::move(a), std::move(b)); }
tree operator +(tree   a, tree   b) { return add_core(std::move(a), std::move(b)); }
tree operator +(tree   a, tree&& b) { return add_core(std::move(a), std::move(b)); }
tree operator +(tree&& a, tree   b) { return add_core(std::move(a), std::move(b)); }

EDIT: воспроизведение отказа оператора использовать неявные преобразования:

#include <iostream>

template<typename T>
class tree;

template<typename T> tree<T> add(tree<T> a, tree<T> b)
{
    std::cout << "added!" << std::endl << std::endl;
    return tree<T>();
}

template<typename T> tree<T> operator +(tree<T>   a, tree<T>   b) { return add(a, b); }

template<typename T>
class tree
{
public:
    tree() { }
    tree(const tree& t) { std::cout << "copy!" << std::endl; }
    tree(double val)    { std::cout << "double" << std::endl; }
    friend tree operator +<T>(tree a, tree b);
};

int main()
{
    tree<double>(1.0) + 2.0;
    return 0;
}

И версия без шаблонов, в которой работает неявное преобразование:

#include <iostream>

class tree
{
public:
    tree() { }
    tree(const tree& t) { std::cout << "copy!" << std::endl; }
    tree(double val)    { std::cout << "double" << std::endl; }
friend tree operator +(tree a, tree b);
};

tree add(tree a, tree b)
{
    std::cout << "added!" << std::endl << std::endl;
    return tree();
}

tree operator +(tree a, tree b) { return add(a, b); }

int main()
{
    tree(1.0) + 2.0;
    return 0;
}

Я думаю, проблема в том, что вы определили операция с неконстантными параметрами. Если вы определяете

tree operator +(const tree& a, const tree& b);

Нет разницы между r-значением и ссылкой на l-значение, поэтому вам не нужно определять также

tree operator +(tree&&      a, const tree& b);

Если вдобавок double конвертируется в дерево как tree x = 1.23; , давайте думать, вам не нужно ни define

tree operator +(double      a, const tree& b){ return tree(a) + b; }

, ни компилятор сделает всю работу за вас.

Вам нужно будет различать rvalues ​​и lvalues, если оператор + принимает параметр дерева по значению

tree operator +(tree a, tree b);

Вы должны определить их как функции-члены, чтобы вам не приходилось перегружать lvalue или rvalue в качестве основной единицы (что в любом случае не нужно).

class Tree {
    Tree operator+ const (const Tree&);
    Tree operator+ const (Tree&&);
};

, поскольку значение l или r первого не имеет значения. Кроме того, компилятор автоматически построит для вас, если этот конструктор доступен. Если дерево строится из double, вы можете автоматически использовать здесь double, и double будет соответствующим образом rvalue. Это всего лишь два метода.