Zwracanie nowo wygenerowanej wartosci w przeladowaniach operatorow

Witam mam pytanko gdy np zwracam nowo wygenerowana wartosc

  point operator+(const point& p)const
    {
        return point(tab[0] + p.tab[0], tab[1] + p.tab[1], tab[2] + p.tab[2]);

    }

to zawsze robie to tak (chociaz nie powinno mi to dzialac bo** .tab[]** jest polem prywatnym)

point(tab[0] + p.tab[0], tab[1] + p.tab[1], tab[2] + p.tab[2])

Natomiast wiem ze powinnienem tak : (ale nie rozumiem dlaczego bez odniesienia sie do komkretnej skladowej tylko nawias kwadratowy )

 
return point(tab[0] + p[0], tab[1] + p[1], tab[2] + p[2])

Czyli nie wiem dlaczego tak moge sie do tego odwolac. Jakby ktos mogl mi troche to rozjasnic chodzi mi ze zamiast** p.tab[0]** uzywam tylko p[0]

#include <iostream>
#include <cmath>
using namespace std;

class point{
    double tab[3];
public:
    point(){tab[0]=tab[1]=tab[2]=0;}
    point(const double (&r)[3]){tab[0]=r[0];tab[1]=r[1];tab[2]=r[2];}
    point(const double &x,const double &y,const double &z){tab[0]=x;tab[1]=y;tab[2]=z;}
    friend ostream& operator << (ostream& out, const point& p);
    const double& operator[](unsigned i)const;
    const double distance(const point& p)const
    {
        return sqrt((p.tab[0]-tab[0])*(p.tab[0]-tab[0])*(p.tab[1]-tab[1])*(p.tab[1]-tab[1])*(p.tab[2]-tab[2])*(p.tab[2]-tab[2]));
    }
    point operator+(const point& p)const
    {
        return point(tab[0] + p.tab[0], tab[1] + p.tab[1], tab[2] + p.tab[2]);

    }
    point operator-(const point& p)const
    {
        return point(tab[0] - p.tab[0], tab[1] - p.tab[1], tab[2] - p.tab[2]);

    }
    point operator*(const double& liczba )const{
    return point(tab[0]*liczba,tab[1]*liczba,tab[2]*liczba);
    }

};
    ostream& operator << (ostream& out, const point& p){
        out << p.tab[0] << " " << p.tab[1] << " " << p.tab[2] ;
        return out;
    }


   const double& point::operator[](unsigned i)const
    {
        if(i>2){cout << " ojoj za duzo"; i = 2;}
        return tab[i];
    }

int main()
{
    double x[2][3] = {{1.0, 1.0, 1.0},
                  {1.0, 2.0, 3.0}};
    point p1(x[0]), p2(x[1]);
    const point p3(0.4, 0.2, 0.1);
    cout << p1 << ", " << p2 << '\n';
    cout << p3[0] << ' ' << p3[1] << ' ' << p3[2] << '\n';
    cout << p1.distance(point()) << ", "<< p3.distance(p1) << '\n';
    cout << p1 + p2 << ", " << p1 - p3 << '\n';
 /*   cout << 3.14 * p2 << ", " << p2 * 3.14 << '\n';
    cout << (p1 < p3) << ", " << (p1 == point(1.0, 1.0,1.0)) << '\n';
    cin >> p1;
    cout << p1 << '\n';*/
    return 0;
}

 

Działa, bo zdefiniowany jest operator [], zdefiniowany tak, że pośredniczy w dostępie do tab i samego obiektu point można używać w kodzie tak, jakby był tablicą...

Dziekuje nie wiedzialem ze to tez jest taki "posrednik" wzgledem pol prywantych :)

Operator działa trochę jak metoda, tylko, że nie wywołuje się jej jako metody, tylko właśnie jako operator, w tym wypadku operator dostępu do tablicy (nie wiem jak to się fachowo nazywa). W tym wypadku, jak wynika z kodu, ta metoda zwraca zadany element tablicy tab.

to zawsze robie to tak (chociaz nie powinno mi to dzialac bo .tab[] jest polem prywatnym)

Dlaczego nie powinno działać? Skoro operator jest zdefiniowany wewnątrz klasy, to znaczy że ma dostęp do prywatnych składowych tej klasy. Dostęp ten działa nie tylko na polach własnego obiektu (this) ale na wszystkich obiektach tej klasy.

dziekuje!!