operator

this->

left.

A &left=*this;

class Foo {
public:
  Foo(int value) {
     // ...
  }
 
  const Foo operator+(const Foo& rhs) const {
    // ...
  }
 
  // ...
};
 
class Bar {
public:
  Bar(int value) {
    // ...
  }
  
  // ...
};
 
const Bar operator+(const Bar& lhs, const Bar& rhs) {
  // ...
}
 
int main() {
  Foo foo1(1);
 
  Foo foo2 = foo1 + 2; // OK
  Foo foo3 = 2 + foo1; // Ошибка
 
  Bar bar1(1);
 
  Bar bar2 = bar1 + 2; // OK
  Bar bar3 = 2 + bar1; // ОК
}

int a = 1;
int b = 2; 
 
(b + a) = 2; // Ошибка

Foo f1(1), f2(2);
 
(f1 + f2) = Foo(3);

#include <iostream>
 
class Foo
{
public:
    Foo(int = 0);
 
    friend const Foo operator+(const Foo &, const Foo &);
 
    friend std::ostream &operator<<(std::ostream &, const Foo &);
 
private:
    int _a;
};
 
Foo::Foo(int a):
_a(a)
{
}
 
const Foo operator+(const Foo &lhs, const Foo &rhs)
{
    return Foo (lhs._a + rhs._a);
}
 
std::ostream &operator<<(std::ostream &output, const Foo &rhs)
{
    return output << rhs._a;
}
 
int main()
{
    Foo a1(10), a2, a3;
 
    a2 = a1 + 2;
    a3 = 5 + a1;
 
    std::cout << a2 << std::endl << a3 << std::endl;
 
    return 0;
}

#include <iostream>
 
class pub
{
public:
    pub(int a_=0):a(a_)
    {
    }
    friend int main(pub one);
private:
    int a;
};
 
int main(pub one)
{
    one.a=5;
    std::cout<<one.a<<'\n';
    return 0;
}