Trzeci - Klasy i praktyka

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <random>

using namespace std;
template<class Re,class Im>
class Zespolona{
public:
    Zespolona(Re rzeczywiste, Im urojona) : rzeczywiste(rzeczywiste), urojona(urojona) {}

    Zespolona(Re rzeczywiste) : rzeczywiste(rzeczywiste) {}

    Zespolona() {}
    bool operator==(const Zespolona &przyslana) const {
        return rzeczywiste == przyslana.rzeczywiste &&
               urojona == przyslana.urojona;
    }

    bool operator!=(const Zespolona &przyslana) const {
        return !(przyslana== *this);
    }

    friend std::ostream &operator<<(std::ostream &os, const Zespolona &zespolona) {
        os << "(" << zespolona.rzeczywiste << "," << zespolona.urojona<<")";
        return os;
    }

    Re getRzeczywiste() const {
        return rzeczywiste;
    }

    void setRzeczywiste(Re rzeczywiste) {
        Zespolona::rzeczywiste = rzeczywiste;
    }

    Im getUrojona() const {
        return urojona;
    }

    void setUrojona(Im urojona) {
        Zespolona::urojona = urojona;
    }


private:
    Re rzeczywiste;
    Im urojona;


};
template <class T>
ostream & operator<<(ostream &os,vector<T> &wektor);
int main() {
    Zespolona<short,long> test;

    vector<Zespolona<int,int>> zespolone(10, {5, 4});
    for(auto &all:zespolone)
    {
        cout<<all<<" ";
    }
    cout<<endl;
    vector<vector<Zespolona<double,double>>> dwa_wymiary_zespolone(10);
    uniform_real<double> generuj(-20,40);
    default_random_engine silnik;

    for(int i=0;i<10;i++)
    {

        for(int j=0;j<5;j++)
        {
            dwa_wymiary_zespolone[i].push_back({generuj(silnik),generuj(silnik)});
        }
    }
    for(auto &all:dwa_wymiary_zespolone)
    {
        cout<<all<<endl;
    }
    vector<Zespolona<double,double>> polaczenie;
    for(auto& all:dwa_wymiary_zespolone)
    {
        for(auto &kazdy:all)
        {
            polaczenie.push_back(kazdy);
        }
    }
   sort(polaczenie.begin(),polaczenie.end(),[](Zespolona<double,double> pierwsza,Zespolona<double,double> druga)->bool{
       return druga.getRzeczywiste()>pierwsza.getRzeczywiste();
   });
    cout<<"Posortuje obiekty wzgledem rosnacej czesci rzeczywistej "<<endl;
    for(auto &all:polaczenie)
    {
        cout<<all<<endl;
    }
//Napisze teraz tablicę wskaźników na obiekty
vector<Zespolona<int,int>*> wskazniki(2); // null , null
    wskazniki[0]=&zespolone[0];//[]
    wskazniki[1]=&zespolone[1];
    wskazniki.push_back(&zespolone[2]);//3
    wskazniki.push_back(&zespolone[3]);//4
    auto iterator=zespolone.begin()+4;
    wskazniki.push_back(&*iterator);//& * iterator to jest wzięcie adresu wyłuskania iteratora
    wskazniki.push_back(&*(iterator+1));
    wskazniki.push_back(new Zespolona<int,int>(23,43));
    wskazniki.push_back(new Zespolona<int,int>(22,41));

    for(auto &all:wskazniki)
    {
        cout<<*all<<" ";// skoro przechowywujemy adresy to musimy je wyłuskać najpierw operatorem *
    }




    std::cout << "Hello, World!" << std::endl;
    return 0;
}
template <class T>
ostream & operator<<(ostream &os,vector<T> &wektor)
{
    for(auto &all:wektor)
    {
        os<<all<<",";
    }
    return os;

}