перегрузка операторов в с ++

Question

предположим, у меня есть 2 объекта класса, и у него есть один элемент данных int. я хочу добавить эти целочисленные данные в другой объект и сохранить выходные данные в элементе данных первого объекта. Я могу перегрузить оператор + и использовать оператор, как показано ниже

X+Y  //where X and Y are objects of one class.

если мне нужно добавить, как показано ниже

X+10// here i want to add 10 to the data member of X.

для выше также я могу перегрузить оператор +.

но если у меня есть 10+X и я хочу добавить 10 к элементу данных X как я могу это сделать?

Answer 1

Точно так же:

MyClass operator+(MyClass const& lhs, MyClass const& rhs);
MyClass operator+(MyClass const& lhs, int rhs);
MyClass operator+(int lhs, MyClass const& rhs);

(operator+ обычно не должен быть членом.)

Если вы перегрузите operator+, вам также понадобится overload +=,Одна частая идиома заключалась в реализации + в терминах + =.Это может быть более или менее автоматизировано (если у вас есть много классов, поддерживающих операторы), определяя что-то вроде:

template<typename DerivedType>
class ArithmeticOperators
{
  public:
    friend DerivedType operator+(
        DerivedType const&  lhs,
        DerivedType const&  rhs)
    {
        DerivedType         result(lhs);
        result += rhs;
        return result;
    }
    //  And so on for the other operators...
protected:
    ~ArithmeticOperators() {}
};

template<typename DerivedType, typename OtherType>
class MixedArithmeticOperators
{
  public:
    friend DerivedType operator+(
        DerivedType const&  lhs,
        OtherType const&    rhs)
    {
        DerivedType         result(lhs);
        result += rhs;
        return result;
    }
    friend DerivedType operator+(
        OtherType const&    lhs,
        DerivedType const&  rhs)
    {
        DerivedType         result(rhs);
        result += lsh;
        return result;
    }
    //  And so on: non-commutative operators only have the
    //  first.
protected:
    ~MixedArithmeticOperators() {}
};

, а затем получая все, что нужно: в вашем случае:

class MyClass : public ArithmeticOperators<MyClass>,
                MixedArithmeticOperators<MyClass, int>

Answer 2

Вы должны создать перегруженный оператор как свободную функцию с правильным порядком параметров:

// This will match "int + YourClass" additions
YourClass operator+(int Left, const YourClass & Right)
{
    // If your addition operation is commutative, you can just call the other
    // version swapping the arguments, otherwise put here your addition logic
    return Right + Left;
}

Если оператору нужно возиться с внутренностями вашего класса, вы можете сделать это friend.

<ч /> Как отмечали другие, есть некоторые лучшие / распространенные практики, которым вы должны следовать, если вы реализуете operator+, я предлагаю вам взглянуть на C ++ - FAQ по перегрузке операторов для получения дополнительной информации о них. .

Answer 3

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

Answer 4

Хотя вы можете сделать это с помощью глобального оператора +, я бы посоветовал этого не делать.

Используйте перегрузку операторов только для тех типов данных, для которых операторы сразу очищаются, например ::100100

• комплексные числа
• строк (+, - хорошо, но * здесь, вероятно, не имеет особого смысла)

Риск с перегруженными операторами заключается в том, что компилятор может выполнять нежелательные преобразования, особенно если вы не делали конструктор с одним аргументом явным.

Answer 5

Вы должны определить функцию, не являющуюся другом.

YourClass operator+(const YourClass &a, const YourClass&b) {

    // do the math here

}

это должен быть друг, чтобы попасть в приватные члены YourClass. Также вы должны создать конструктор для YourClass, который займет int.

Таким образом, у вас есть один operator+, а для каждого другого int вы просто создаете другого конструктора.

Answer 6

Определить автономную свободную функцию, не являющуюся членом, как:

sample operator+(int leftOperand, const sample & rightOperand)
{
   //...
}