Неявное преобразование в перегруженном операторе

Question

d1 + 4 работает, но 4 + d1 не работает, хотя 4 можно неявно преобразовать в GMan.Почему они не эквивалентны?

struct GMan
{
    int a, b;

    GMan() : a(), b() {}
    GMan(int _a) : a(_a), b() {}
    GMan(int _a, int _b) : a(_a), b(_b) {}

    GMan operator +(const GMan& _b)
    {
         GMan d;
         d.a = this->a + _b.a;
         d.b = this->b + _b.b;
         return d;
    }
};

int main()
{
    GMan d1(1, 2), d(2);
    GMan d3;
    d3 = d1 + 4; 
    d3 = 4 + d1;
}

Answer 1

Вызов x + y переводится компилятором C ++ в любой из следующих двух вызовов (в зависимости от того, относится ли x к типу класса и существует ли такая функция):

1. Функция-член

   x.operator +(y);
   

2. Свободная функция

   operator +(x, y);
   

Теперь в C ++ есть простое правило: до этого не может быть неявного преобразованияоператор доступа пользователя (.).Таким образом, x в вышеприведенном коде не может подвергаться неявному преобразованию в первом коде, но может происходить во втором.

Это правило имеет смысл: если x может быть неявно преобразовано в первом кодевыше, компилятор C ++ больше не будет знать, какую функцию вызывать (т.е. к какому классу он принадлежит), поэтому ему придется искать во всех существующих классах на предмет соответствия функции-члена.Это может разрушить систему типов C ++ и сделать правила перегрузки еще более сложными и запутанными.

Answer 2

Этот ответ правильный.Затем эти пункты влекут за собой канонический способ реализации таких операторов:

struct GMan
{
    int a, b;

    /* Side-note: these could be combined:
    GMan():a(),b(){}
    GMan(int _a):a(_a),b(){}
    GMan(int _a, int _b):a(_a),b(_b){}
    */
    GMan(int _a = 0, int _b = 0) : a(_a), b(_b){} // into this

    // first implement the mutating operator
    GMan& operator+=(const GMan& _b)
    {
        // the use of 'this' to access members
        // is generally seen as noise
        a += _b.a;
        b += _b.b;

        return *this;
    }
};

// then use it to implement the non-mutating operator, as a free-function
// (always prefer free-functions over member-functions, for various reasons)
GMan operator+(GMan _a, const GMan& _b)
{
    _a += b; // code re-use
    return _a;
}

И так далее для других операторов.