Jak rozumieć wskaźnik *this?

Czytałem o nim sporo, próbowałem zrozumieć, ale ciągle nie mogę. Wiem że jest to zwrócenie się do obiektu z klasy na którym są aktualnie wykonywane jakieś operacje.

Mam np. taką funkcję publiczną:

wek& operator-(); //// zmienia znaki wszystkich elementow (deklaracja)
 
wek& wek :: operator-() //definicja
 {
	 for(int i=0; i<n; i++)
		 x[i] = -x[i];

	 return *this;
 }

Co ta funkcja zwraca?

wek operator+(const wek&) const;  // dodawanie: wek + wek (deklaracja)
wek wek :: operator+(const wek& vect) const //definicja
 {
	 wek newvector = *this;
	 for(int i=0; i<n; i++)
		 newvector.x[i] += vect.x[i];

	 return newvector;
 }

Jak mam rozumieć w tym przykładzie użycie wskaźnika na this?

johanneskate napisał(a)

Co ta funkcja zwraca?

Referencje do samego siebie. Skoro this to wskaźnik na samego siebie to operator wyłuskania użyty na this zwraca obiekt, na który ten this wskazuje, a że sygnatura podanej przez Ciebie metody jasno mówi, że zwraca referencje to zostanie zwrócona referencja do tego obiektu, a nie jego kopia.

To zależy od działania operatora = dla klasy wek. Prawdopodobnie tworzy ona kopię obiektu po prawej stronie -> czyli tego obiektu, na który wskazuje this (*this to wyłuskanie obiektu, na który wskazuje wskaźnik this).

johanneskate napisał(a)

można by troszeczkę jaśniej? :D Wiem jak działa *this, bo czytałem. Po prostu tego nie widzę

Konkretnie czego nie widzisz ?

johanneskate napisał(a)

wek operator+(const wek&) const;  // dodawanie: wek + wek (deklaracja)
wek wek :: operator+(const wek& vect) const //definicja
 {
	 wek newvector = *this; // stworz newvector jako coś, co zwraca operator "=" gdy dostanie obiekt (w tym wypadku obiekt *this)
	 for(int i=0; i<n; i++)
		 newvector.x[i] += vect.x[i]; // jakaś tam iteracja

	 return newvector; // zwróć utworzony wcześniej obiekt newvector
 }

 wek newvector = *this; // stworz newvector jako coś, co zwraca operator "=" gdy dostanie obiekt (w tym wypadku obiekt *this)

Czyli to będzie zawsze zwracało = (tzn co dokładnie robiło?) kiedy dostanie jakikolwiek obiekt odpowiedniego typu?

Tak wygląda definicja operatora "=":

wek& wek :: operator=(const wek& vector)
{
	n = vector.n;

	x = new double[n];
	for(int i=0; i<n; i++)
		x[i] = vector.x[i];

	return *this;
}

Teoretycznie możesz to zrobić tak:

void wek::operator=(const wek &vector)
  {
   //tu przypisania
  }

i nawet będzie działać:

wek x,y;
x=y;

ale już:

wek x,y,z;
x=y=z;

nie zadziała.
Aby zadziałało operator= musi zwrócić albo referencje na inicjalizowany obiekt:

[const] wek &wek::operator=(const wek &vector)
  {
   //tu przypisania
   return *this;
  }

albo referencje na inicjalizujący obiekt:

const wek &wek::operator=(const wek &vector)
  {
   //tu przypisania
   return vector;
  }

albo obiekt przez wartość, to akurat rzadko stosowane i rzadko jest dobrym posunięciem, więc nawet nie daje przykładu.
Samo:

return *this;

Można rozpatrywać jako:

wek *ptr=this;
wek &ref=*ptr;
return ref;