Is operator overloading necessary to learn?

[cppnoob25]

Will I really use it in my programming career? I've read in a lot of places that it is not necessary as it usually causes ambiguity. So why do professors teach this and not something that is considered more useful?

Sample code with operator overloading and without

#include <iostream>
using namespace std;

class Box
{
   public:

      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }

      void setBreadth( double bre )
      {
          breadth = bre;
      }

      void setHeight( double hei )
      {
          height = hei;
      }
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};
// Main function for the program
int main( )
{
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here
 
   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

without

#include <iostream>
using namespace std;

class Box
{
   public:

      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }

      void setBreadth( double bre )
      {
          breadth = bre;
      }

      void setHeight( double hei )
      {
          height = hei;
      }


      Box addboxes(Box& box1, Box& box2)
      {
          Box box;
          box.length = box1.length + box2.length;
          box.breadth = box1.breadth + box2.breadth;
          box.height = box1.height + box2.height;
          return box;
      }

   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};
// Main function for the program
int main( )
{
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here

   // box 1 specification
   Box1.setLength(6.0);
   Box1.setBreadth(7.0);
   Box1.setHeight(5.0);

   // box 2 specification
   Box2.setLength(12.0);
   Box2.setBreadth(13.0);
   Box2.setHeight(10.0);

   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;

   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box3.addboxes(Box1, Box2);

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

This is a fairly simple problem and when you add the boxes with the overloaded operator it looks nice and easy but I know that there are more complex problems that are hard to comprehend when you overload the operator.

Can't I just accomplish everything that operator overloading accomplishes with a function like done above?

I've replaced this

      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }

with this

      Box addboxes(Box& box1, Box& box2)
      {
          Box box;
          box.length = box1.length + box2.length;
          box.breadth = box1.breadth + box2.breadth;
          box.height = box1.height + box2.height;
          return box;
      }

[Disch]

Will I really use it in my programming career?

Yes.

I've read in a lot of places that it is not necessary as it usually causes ambiguity.

Newbies tend to overuse/abuse operator overloading, so it's often downplayed to dissuade that. But really it's very useful.

So why do professors teach this and not something that is considered more useful?

They teach it because it is useful and is a key part of the C++ language.

Can't I just accomplish everything that operator overloading accomplishes with a function like done above?

Yes. Just about everything you can do with operator overloading you can do with a function. But that's not the point.

The point is... operator overloading is meant to make the code more intuitive.

Your Box class is a very bad example and that is a case where you should definitely not use operator overloading. Conceptually, summing two boxes makes no logical sense... so overloading the + operator is a bad idea.

A good example is a mathematical vector class:

class Vector2
{
public:
    float x, y;

    // assume +, -, *, /, +=, -=, etc operators are overloaded
};

// then you can do things like this:

Vector2 a, b;

a.x = 5;
a.y = 3;

a *= 2.3f;
b = a;

a.x = 1;
a += b;

//etc 

It effectively lets you create classes that function more like fundamental types. It allows code to be simpler and easier to follow. Compare that with the alternative:

a.multAssign(2.3f);
b = a;

a.x = 1;
a.addAssign(b);

Yes it accomplishes the same thing, but at-a-glance it isn't as intuitive.

Furthermore... it's useful for other kinds of types... like iterators...

// simple enough, but only because the ++ operator is overloaded for the iterator
for(someiterator i = vec.begin(); i != vec.end(); ++i)

// without overloading, you'd need to do something like this:
for(someiterator i = vec.begin(); i != vec.end(); i.next())

And the [] operator is frequently overloaded for container classes, like vector, map, string, etc.

And the << and >> operators are frequently overloaded in classes so that they can be easily sent to/from streams.

Operator overloading is all over the language and the standard library. So yes it is an important concept to learn.

[cppnoob25]

Thanks for your input on this Disch, I understand more now.