Перегрузка нескольких операторов C++ для одного и того же оператора

Question

Я знаю, что могу легко ответить на этот вопрос самому себе, указав код и посмотрев, скомпилирован ли он. Но так как я не мог найти подобный вопрос, я думал, что это ценность для обмена знаниями. Скажем, я перегружаю оператор + для MyClass. Могу ли я перегрузить его несколько раз. Различные перегрузки для разных типов. Как это:

class MyClass{ 
... 
inline const MyClass operator+(const MyClass &addend) const { 
    cout<<"Adding MyClass+MyClass"<<endl; 
    ...//Code for adding MyClass with MyClass 
} 
inline const MyClass operator+(const int &addend) const { 
    cout<<"Adding MyClass+int"<<endl; 
    ...//Code for adding MyClass with int 
} 
... 
}; 
int main(){ 
    MyClass c1; 
    MyClass c2; 
    MyClass c3 = c1 + c2; 
    MyClass c4 = c1 + 5; 
} 
/*Output should be: 
    Adding MyClass+MyClass 
    Adding MyClass+in*/ 

Поэтому я хочу, чтобы сделать это, что я строю класс, который я хочу быть оптимизированы, насколько это возможно. Для меня здесь самое большое беспокойство. Так что литье и использование корпуса переключателя внутри оператора + перегруженная функция не является вариантом. Я заметим, я сделал и перегрузку встроенной. Предположим на секунду, что компилятор действительно устанавливает мои перегрузки, тогда он предопределен во время компиляции, который будет запускаться, и я сохраняю вызов функции (путем inlining) + сложный сценарий сценария переключения (в действительности, будет 5+ перегрузки для оператора +), но я все еще могу писать легко читаемый код с помощью основных арифметических операторов. Итак, я получу желаемое поведение?

Answer 1

Каноническая форма реализации operator+() является бесплатной функцией на основе operator+=(), которую ожидают ваши пользователи, если у вас есть +. += изменяет свой левый аргумент и поэтому должен быть членом. + рассматривает свои аргументы симметрично и, следовательно, является свободной функцией.

Что-то вроде этого нужно сделать:

//Beware, brain-compiled code ahead! 
class MyClass { 
public: 
    MyClass& operator+=(const MyClass &rhs) const 
    { 
     // code for adding MyClass to MyClass 
     return *this; 
    } 
    MyClass& operator+=(int rhs) const 
    { 
     // code for adding int to MyClass 
     return *this; 
    } 
}; 


inline MyClass operator+(MyClass lhs, const MyClass& rhs) { 
    lhs += rhs; 
    return lhs; 
} 
inline MyClass operator+(MyClass lhs, int rhs) { 
    lhs += rhs; 
    return lhs; 
} 
// maybe you need this one, too 
inline MyClass operator+(int lhs, const MyClass& rhs) { 
    return rhs + lhs; // addition should be commutative 
} 

(Обратите внимание, что функции-члены, определенные с их классом определение неявно inline Также обратите внимание, что в MyClass префикс MyClass:: либо не требуется или даже не так..)

Answer 2

Да.

---

Эти функции оператора являются только обычные функции со специальными именами operator@. Нет никаких ограничений, что они не могут быть перегружены. Фактически, оператор <<, используемый iostream, является оператором с несколькими перегрузками.

Answer 3

Да, вы можете перегружать таких операторов. Но я не уверен, что вы имеете в виду «switch case». Вы можете жить с одной перегрузкой, если у вас есть конвертирующий конструктор.

class MyClass{ 
... 
// code for creating a MyClass out of an int 
MyClass(int n) { ... } 
... 
inline const MyClass MyClass::operator+(const MyClass &addend) const { 
    cout<<"Adding MyClass+MyClass"<<endl; 
    ...//Code for adding MyClass with MyClass 
} 
... 
}; 

Никакой коммутатор не требуется вообще. Это имеет право, если «MyClass» логически представляет число.

Обратите внимание, что вы должны перегружать эти операторы функциями, не являющимися членами. В вашем коде 5 + c1 не будет работать, потому что нет оператора, который принимает int как левую сторону. Ниже будет работать

inline const MyClass operator+(const MyClass &lhs, const MyClass &rhs) { 
    // ... 
} 

Теперь, если вы держите преобразующий конструктор вы можете добавить ИНТ на обе стороны с минимальным кодом накладных расходов.