Operator Overloading in C++ as Int + Obj

operator overloading in c++ with an integer and an object

to implement i+list1 you must define a friend non member operator like

class SortedDoublyLinkedList {
...

friend SortedDoublyLinkedList operator+(int i, const SortedDoublyLinkedList &_list);
};

SortedDoublyLinkedList operator+(int i, const SortedDoublyLinkedList &_list) {
    SortedDoublyLinkedList newlist(_list);
    newlist.add(i);
    return newlist;
}

Return Integer while overloading operator plus 2 object in c++

Because the operator is defined inside the class it's left hand side must be of type Sum and the right hand side must be of type Sum* (because that's the type of parameter d1).

However, you try to add two pointers here:

int result = num1 + num2;

Correct would be to dereference the left hand side

//           V
int result = *num1 + num2;

Even better would be to overload the operator with a reference as right hand side argument and don't use new at all (You don't really need to use new in modern C++).

//             VVVVV     V
int operator+ (const Sum &d1) {
    return this->getNumber() + d1.getNumber();
}

...

int main() {
    Sum num1(17);
    Sum num2(9);

    int result = num1 + num2;
    cout << result;
}

How to overload + operator that can work on objects of class largeIntegers that can store a number upto 100 digits in an array?

The problem is that your overloaded operator+ was returning a reference to a local variable. To solve this, you can instead use the following version of operator+:

//return by value 
largeIntegers operator+(const largeIntegers &lhs, const largeIntegers &integer)
{
   largeIntegers temp;
  int remainder = 0;
  int digi = max(lhs.digits, integer.digits);
  temp.digits = digi;
  for (int i = 0; i < digi; i++) {
    temp.num[i] = (remainder + lhs.num[i] + integer.num[i]) % 10;
    remainder = (remainder + lhs.num[i] + integer.num[i]) / 10;
  }
  if (remainder) {
    temp.num[digi] = remainder;
    temp.digits++;
  }

  return temp;
}

For the above to work make operator+ a friend by adding a friend declaration as follows inside the class:

friend largeIntegers operator+(const largeIntegers &lhs, const largeIntegers &rhs);

The complete working program that uses the above shown modification can be seen here and is given below:

#include <bits/stdc++.h>

using namespace std;

class largeIntegers {
private:
  /* data */
  int num[100] = {0};
  int digits;
  bool isPositive;

public:
  friend istream &operator>>(istream &, largeIntegers &);
  //i have added this friend declaration
  friend largeIntegers operator+(const largeIntegers &lhs, const largeIntegers &rhs);
  void getLargeInteger(void);
  void setLargeInteger(string);
  void print(void);
  largeIntegers();
  largeIntegers(string);
};

int main() {
  largeIntegers num1;
  cin >> num1;
  largeIntegers num2;
  num2 = num1;
  cin >> num1;

  largeIntegers num3;
  num3 = num1 + num2;
  num3.print();
  return 0;
}
//i have modified the operator+ as shown below
largeIntegers operator+(const largeIntegers &lhs, const largeIntegers &integer)
{
   largeIntegers temp;
  int remainder = 0;
  int digi = max(lhs.digits, integer.digits);
  temp.digits = digi;
  for (int i = 0; i < digi; i++) {
    temp.num[i] = (remainder + lhs.num[i] + integer.num[i]) % 10;
    remainder = (remainder + lhs.num[i] + integer.num[i]) / 10;
  }
  if (remainder) {
    temp.num[digi] = remainder;
    temp.digits++;
  }

  return temp;
}

largeIntegers::largeIntegers(string n) { setLargeInteger(n); }

largeIntegers::largeIntegers() {
  isPositive = true;
  digits = 0;
}

void largeIntegers::setLargeInteger(string n) {
  int start = 0;
  if (n[0] == '-') {
    isPositive = false;
    start = 1;
  }
  digits = 0;
  for (int i = n.length() - 1; i >= start; i--) {
    num[digits] = int(n[i]) - int('0');
    digits++;
  }
}

void largeIntegers::getLargeInteger(void) {
  cout << "Enter a large integer:\n";
  string n;
  cin >> n;
  setLargeInteger(n);
}

istream &operator>>(istream &isObject, largeIntegers &largeInt) {
  string num;
  isObject >> num;
  largeInt.setLargeInteger(num);

  return isObject;
}

void largeIntegers::print(void) {
  if (!isPositive)
    cout << "-";
  for (int i = digits - 1; i >= 0; i--) {
    cout << num[i];
  }
  cout << endl;
}

See the comments in the above code to check the modifications i made

Operator Overloading c++ adding int to object

You will need to define another overload of operator+ that takes an int as argument:

  upDate upDate::operator+(int days) const{    
    upDate temp(*this);
    temp.day += days;
    return temp;
 }

Edit: as Dolphiniac has noted, you should define a copy constructor to initialize temp correctly.

Can we overload operators for built-in types like int or float?

You cannot redefine a built-in operator. Operator overloading
is designed to allow you to extend the language, not to change
it. At least one of the parameters of an overloaded operator
must be a user defined type (class or enum type) or a reference
to a user defined type.

How to overload object = constant int + object

It's simple, define the overload out of class

class mango
{
    ...
};

mango operator+(const int a, const mango& b)
{
    ...
}

In fact it's generally reckoned that all symmetric and anti-symmetric operators should be defined out of class. So your mango + int should also be moved out of the class.

mango operator+(const mango& a, const int b)
{
    ...
}

Overloading operator + and doing a + b where a is int and b custom object

Overloading operator + and doing a + b where a is int and b custom object

By defining the overload operator+(int a, custom b).

It may however be preferable to make the custom type implicitly constructible from int in which case you would only need one operator overload operator+(custom a, custom b) which would work with all combinations of custom and int.

Can I overload an operator in Objective-C?

Operator overloading is not a feature of Objective-C. If two instances of your classes can be added together, provide a method and allow them to be added using that method:

Thing *result = [thingOne thingByAddingThing:thingTwo];

Or, if your class is mutable:

[thingOne addThing:thingTwo];

---

Related Topics