obiektowość - prosty program do zabawy z wektorami

dopiero zaczynam zabawę z programowaniem obiektowym więc proszę o wyrozumiałość, zadanie polega na napisanie prostego programu do reprezentacji wektorow. Napisałem cos takiego:

//#define TEST
#include <iostream>
#include <math.h>
using namespace std;
class Punkt
{
	float p_x,p_y;
public:
	Punkt()
	{
        p_x = 0.0;
        p_y = 0.0;
        #ifdef TEST
        cout << "konstruktor domyslny pkt \n";
        #endif
    }
	Punkt(float px, float py)
	{
		p_x = px;
		p_y = py;
		#ifdef TEST
		cout << "konstruktor ff pkt \n";
		#endif
	}
	float zwroc_x()
	{
		return(p_x);
	}

	float zwroc_y()
	{
		return(p_y);
	}
    #ifdef TEST
	~Punkt(){cout << "destruktor pkt \n";}
	#endif
};

class Wektor
{
private:
	float w_X, w_Y;
	float dlugosc;
public:
	Wektor(Punkt pkt1, Punkt pkt2)
	{

        #ifdef TEST
        cout << "konstruktor wektor \n";
        #endif
		w_X = pkt1.zwroc_x()-pkt2.zwroc_x();
		w_Y = pkt1.zwroc_y()-pkt2.zwroc_y();
		dlugosc = sqrt(w_X*w_X + w_Y * w_Y );

	}

	~Wektor(){
	    #ifdef TEST
	cout << "destruktor wektor\n";
	#endif
	}

	float w_dlugosc()
	{
	    dlugosc=sqrt(w_X*w_X + w_Y * w_Y);
	    return(dlugosc);
	}
	void wyswietl(Punkt pkt1, Punkt pkt2)
	{
		std::cout << "wektor o wspolrzednych pkt A \n" << pkt1.zwroc_x()<< "," << pkt1.zwroc_y() << "\n";
		std::cout << "punkt B  \n" << pkt2.zwroc_x() << "," << pkt2.zwroc_y() << "\n";
		std::cout << "dlugosc: \n" << dlugosc << "\n";
	}


	//float dl_wektora()
	//{
};

int main()
{
short wybor;
  Punkt punkt1(1.0,2.0);
        Punkt punkt2(2.0,1.0);
          Wektor wektor1(punkt1,punkt2);
wektor1.wyswietl(punkt1,punkt2);



	return(0);
}
 

pytanie 1: czy jest to zgodne z pisaniem w sposob obiektowy bo nie do konca rozumiem idee.
pytanie 2: mam przeciazyc operatory dodawania i odejmowania powinienem to zrobic w klasie wektor?

Opakowywanie prymitywów w klasy jest zgodne z nurtem obiektowym. Ten sam nurt skłania się ku konwencji modułów, czyli powinieneś swoje klasy rozdzielić na dwa pliki.
ad.2
To zależy co chcesz dodawać i odejmować? Wektory czy punkty? Przeciążanie operatora wykonujesz w klasie dla której instancji potrzebujesz tegoż operatora.

chcę dodawać wektory

Wektor operator + (Wektor, Wektor)
    {
        
    }
 

i teraz chciałbym dodać po kolei kazdą skladowa tylko czy tzn ze mam sie odwolywac do prywatnych skladnikow Wektor?

czy dopisac sobie 2 metody zwracajace te skladowe (tak jak w klasie Punkt)

Zadeklaruj operator + jako metodę klasy Wektor, wtedy masz dostęp do składowych wewnętrznych (wtedy podajesz tylko prawą stronę operatora jako parametr, lewą stroną jest *this), ewentualnie możesz zrobić przyjaźń dla tego operatora (przyjaźń jest lepsza, niż robienie pól publicznych). Z drugiej strony nie wiem, czy akurat współrzędne w wektorze powinny być prywatne, choć to zależy od struktury projektu.

Edit: przypomniałem sobie, akurat w wektorze to składowe powinny być prywatne i dojście do nich powinno być przez metodę. Główny powód jest związany z tym, że wiele algorytmów jest prostszych do implementacji i szybszych na wektorach we współrzędnych homogenicznych, więc ewentualna zmiana wewnętrznej reprezentacji nie wymaga zmiany reszty aplikacji.