Operatory

#include <iostream>
#include <cstring>
#include <string.h>
#include <vector>

int liczba;
using namespace std;

class Wektor
{
    private:
        double x, y, z;
        double s[3];

    public:
        double get_x()
        {
            return x;
        }
        double get_y()
        {
            return y;
        }
        double get_z()
        {
            return z;
        }
        void show()
        {
//          cout << "x: " << x << " y: " << y << " z: " << z << endl;
            printf_s("(x y z) = \t%.2lf \t%.2lf \t%.2lf\n", s[0], s[1] ,s[2]); // wolę tak :D
        }

        Wektor() { x = y = z = 0; } // domyślne zerowy
        Wektor(double x, double y, double z)
        {
            this->x = x;
            this->y = y;
            this->z = z;
            s[0] = x; s[1] = y; s[2] = z;
        }

        Wektor operator+(Wektor o_dodac)
        {
          for (int i = 0; i < 3; i++)
            {
              o_dodac.s[i] += this->s[i];
            }
            return o_dodac;
        }

        Wektor operator*(Wektor o_pomnozyc)
        {
            Wektor tmp;

            tmp.x = x * o_pomnozyc.x;
            tmp.y = y * o_pomnozyc.y;
            tmp.z = z * o_pomnozyc.z;

            return tmp;
        }

        Wektor operator-(Wektor o_odjac)
        {
            Wektor tmp;

            tmp.x = x - o_odjac.x;
            tmp.y = y - o_odjac.y;
            tmp.z = z - o_odjac.z;
            return tmp;
        }

//        friend std::ostream & operator << (std::ostream& os, Wektor &w)
//        {
//            os << w.x;
//            return os;
//        }
        friend Wektor operator/(Wektor &A, double scalar);

};

Wektor operator/(Wektor &A, double scalar)
{
  for (int i = 0; i < 3; i++)
    {
      A.s[i] /= scalar;
    }
  return A; // ? Wiesz po co zwracać wektor skoro i tak podajemy
            // referencję czyli podmieniamy oryginalne wartości?
}






int main()
{

//    vector <Wektor> T_wynikow;

//    Wektor wspolrzedne[]={
//        Wektor(4.5,3.7,6.2),
//        Wektor(2.8,8.4,4.3),
//    };

    Wektor w_1(4.5,3.7,6.2);
    Wektor w_2(2.3,5.8,9.6);
    Wektor wynik_dodawania = w_1 + w_2;
    Wektor wynik_odejmowania = w_1 - w_2;
    Wektor wynik_mnozenia = w_1 * w_2;
//    Wektor wynik_w1_liczba = liczba * w_1;
//    Wektor wynik_w2_liczba = liczba * w_2;

     // ================= DODAWANIE ================= //
        cout << "DODAWANIE wektorow A[4.5,3.7,6.2] | B[2.3,5.8,9.6]" << endl;

//        wynik_dodawania.operator=(wynik_mnozenia);
        wynik_dodawania.show();
        puts("Dzielenie:");
        wynik_dodawania = wynik_dodawania / 2. ;
        wynik_dodawania.show();

        return 0xC0fee;
        //        cout << "Wartosc dodawania x = " << wynik_dodawania.get_x() << endl;
//        cout << "Wartosc dodawania y = " << wynik_dodawania.get_y()<< endl;
//        cout << "Wartosc dodawania z = " << wynik_dodawania.get_z() << endl;
    // ================= DODAWANIE ================= //

//        cout << endl;

    // ================= ODEJMOWANIE ================= //
        cout << "DODAWANIE wektorow A[4.5,3.7,6.2] | B[2.3,5.8,9.6]" << endl << endl;
        cout << "Wartosc odejmowania x = " << wynik_odejmowania.get_x() << endl;
        cout << "Wartosc odejmowania y = " << wynik_odejmowania.get_y()<< endl;
        cout << "Wartosc odejmowania z = " << wynik_odejmowania.get_z() << endl;
    // ================= ODEJMOWANIE ================= //

        cout << endl;

    // ================= MNOZENIE SKALARNE ================= //
         cout << "MNOZENIE skalarne wektorow A[4.5,3.7,6.2] | B[2.3,5.8,9.6]" << endl << endl;
         cout << "Wartosc mnozenia wektorow skalarnie = " << wynik_mnozenia.get_x() + wynik_mnozenia.get_y() + wynik_mnozenia.get_z() << endl;

    // ================= MNOZENIE SKALARNE ================= //

         cout << endl;

    // ================= MNOZENIE PRZEZ LICZBE ================= //
        cout << "DODAWANIE wektorow A[4.5,3.7,6.2] | B[2.3,5.8,9.6]" << endl << endl;
//        cout << "Mnozenienie pierwszego wektora przez "<< liczba << " = [" << wynik_w1_liczba.get_x() + wynik_w1_liczba.get_y() + wynik_w1_liczba.get_z() << "]" << endl;
    // ================= MNOZENIE PRZEZ LICZBE ================= //


    return 0;
}