Operators overloading in c++

Question

I recently found out about overloading operators in c++. When you want to overload a operator in class , and we want to create new object with it , that is made from others we defined we can do

NameOfClass operator+(const NameOfClass& b){
  {
         NameOfClass tmp;
         tmp.length = this->length + b.length;
         tmp.breadth = this->breadth + b.breadth;
         tmp.height = this->height + b.height;
         return  tmp;

}

I cant figure out if i define 2 objects before this. eg

NameOfClass one(length,breadth,height);
NameOfClass two(length,breadth,height);

I set their attributes. but how does

NameOfClass three=one+two;

set the attributes of "three"? Are both one and two considered as argument to "+" overloaded operator. The function clearly says

tmp.length = this->length + b.length;

but this-> length should be undefined and b.length is private. How does it mix it together? Or is it taken as method so one+two = the + is method of one and two is being passed as argument , meaning that this->length reffers to to length of "one" object? Using example from tutorialspoint.

#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;
}

Answer 1

1.

how does

 NameOfClass three=one+two; 

set the attributes of "three"?

NameOfClass three=one+two; will be interpreted as NameOfClass three = one.operator+(two); , and three will be copy/move constructed from the return value of NameOfClass::operator=() .

2.

 tmp.length = this->length + b.length; 

but this-> length should be undefined and b.length is private. How does it mix it together?

What do you mean "this-> length should be undefined"? Here this == &one and b == two .

b.length is private doesn't matter because operator+ is the member function, it could access the private member.

Answer 2

NameOfClass three = one + two; will use a compiler-generated copy constructor in order to construct three from the anonymous temporary one + two . one + two is syntactic sugar for one.operator+(two) which you have implemented.

Smarter compilers may well use a compiler-generated move constructor since it's clear that the anonymous temporary can't be used by anything else.

You can implement those constructors yourself, or rely on the compiler generating one which copies (or moves ) the member data.