仅具有成员函数的C ++重载+运算符，用于添加带有整数的类对象

Question

I want to know how the operator+ member function and operator= member will be written for below statements in main .

I do not want to add friend functions.

int main(){
  A obj1, obj2, obj3;

  obj2 = obj1 + 10;

  obj3 = 20 + obj1;

  return 0;

}

//Below is my class

//Please add necessary assignment and additions operator+ functions

class A{

   int i;

 public :

      A(){i = 0;}

     A& operator=(const A &obj){

        i = obj.i;
        return *this;
    }
};

Answer 1

You say you don't want to use a friend function, but tough, that is the correct way. You have no need for a custom assignment operator. The implicit constructor will automatically turn the integer into an instance of A. This will work with your code in main.

class A
{
public :
    A(int i = 0) : i(i) {}

    friend A operator + (const A& left, const A& right)
    {
        return A(left.i + right.i);
    }

private:
    int i;
};

Answer 2

obj = obj1 + 10; can be solved with the following defined operator:

A operator+( int rhs ){
  return A( i + rhs );
}

the other way around is a problem, due to int being a non class type. IMO you cannot solve this without friend operators, because member operators imply that the left hand system is a class type, you will need for overloading.

Here is a link to a very good answer to a similar question

Answer 3

Slightly different solution:

class A
{
public :
    A(int i = 0) : i(i) {}

    A operator+(int addition)
    {
        return A(i + addition);
    }

private:
    int i;
};

A operator+(int addition, const A& a)
{
    return a + addition;
}

Answer 4

Operator= will work as you have written in your code snippet. For addition, member function will not work, one alternative is...

//Define following members functions and attributes in class
class A
{
private:
  int i;

public:
  //1) implicit constructor for conversion from int
  A (int i_ = 0) : i (i_) {}

  //2) public function for addition
  A Add (A const& copy)
  { return A (i + copy.i); }
};

//You can call A::Add from global operator+ function without it being friend
A operator+ (A const& left, A const& right)
{ return left.Add (right); }

Answer 5

#include<iostream>
using namespace std;

class A{

     int i;

 public :

     A(){i = 0;}
     A& operator=(int obj){

        i = obj;
        return *this;
    }
    int operator+(){
        return this->i;
    }
    int operator-(){
        return -1*this->i;
    }
    A operator+(int a){
        this->i=a+this->i;
        return *this;
    }
};


int main(){
  A obj1, obj2, obj3;

  obj2 = obj1 + 10;

  obj3 = 20 + +obj1;

  return 0;

}

Is that solve your problem?I hope this will help.