Tworzenie figur korzystając z kompozycji

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

class Punkt
{
    int x, y;

public:

    Punkt()
    {
        x = y = 0;
    }

    Punkt(int x, int y)
    {
        this->x=x;
        this->y=y;
    }

    void przesun(int dx, int dy)
    {
        x+=dx;
        y+=dy;
    }
};

class Linia
{
    Punkt *p1, *p2;

public:

    Linia()
    {
        p1 = new Punkt();
        p2 = new Punkt(1,1);
    }

    Linia(Punkt &p1, Punkt &p2)
    {
        this->p1 = new Punkt(p1);
        this->p2 = new Punkt(p2);
    }

    Linia(const Linia &l)
    {
        this->p1 = l.p1;
        this->p2 = l.p2;
    }

    void przesun(int dx, int dy)
    {
        p1->przesun(dx,dy);
        p2->przesun(dx,dy);
    }

    ~Linia()
    {
        delete p1;
        delete p2;
    }
};

class Trojkat
{
    Linia *l1, *l2, *l3;

public:

    Trojkat()
    {
        this->l1 = new Linia();
        this->l2 = new Linia();
        this->l3 = new Linia();
    }

    Trojkat(Punkt &a, Punkt &b, Punkt &c)
    {
        l1 = new Linia(a,b);
        l2 = new Linia(b,c);
        l3 = new Linia(c,a);
    }

    Trojkat(const Trojkat &trojkat)
    {
        this->l1 = trojkat.l1;
        this->l2 = trojkat.l2;
        this->l3 = trojkat.l3;
    }

    void przesun(int dx, int dy)
    {
        l1->przesun(dx, dy);
        l2->przesun(dx, dy);
        l3->przesun(dx, dy);
    }

    ~Trojkat()
    {
        delete l1;
        delete l2;
        delete l3;
    }

};

class Czworokat
{
    Linia *l1, *l2, *l3, *l4;

public:

    Czworokat()
    {
        this->l1 = new Linia();
        this->l2 = new Linia();
        this->l3 = new Linia();
        this->l4 = new Linia();
    }

    Czworokat(Punkt &a, Punkt &b, Punkt &c, Punkt &d)
    {
        this->l1 = new Linia(a, b);
        this->l2 = new Linia(b, c);
        this->l3 = new Linia(c, d);
        this->l4 = new Linia(d, a);
    }

    Czworokat(const Czworokat &czworokat)
    {
        this->l1 = czworokat.l1;
        this->l2 = czworokat.l2;
        this->l3 = czworokat.l3;
        this->l4 = czworokat.l4;
    }

    void przesun(int dx, int dy)
    {
        l1->przesun(dx,dy);
        l2->przesun(dx,dy);
        l3->przesun(dx,dy);
        l4->przesun(dx,dy);
    }

    ~Czworokat()
    {
        delete l1;
        delete l2;
        delete l3;
        delete l4;
    }
};

class Obraz
{
    Trojkat *TablicaTrojkat = new Trojkat [20];
    int licznik = 0;

public:

    void DodajTrojkat(Trojkat trojkat)
    {
        TablicaTrojkat[licznik++] = trojkat;
    }
};

int main()
{
    Punkt *pierwszy = new Punkt(1,1);
    Punkt *drugi = new Punkt(2,2);
    Punkt *trzeci = new Punkt(4,8);
    Punkt *czwarty = new Punkt (15,17);

    Linia *l1 = new Linia(*pierwszy,*drugi);
    l1->przesun(4,4);

    Trojkat *trojkat = new Trojkat(*pierwszy,*drugi,*trzeci);

    Czworokat *czworokat = new Czworokat(*pierwszy,*drugi,*trzeci,*czwarty);

    return 0;
}
 

#include <iostream>
#include <vector>
#include <list>
#include <string>

class Punkt{
public:
    Punkt(float x, float y) : x(x), y(y) { }
    float zwrocX(){ return this->x; }
    float zwrocY(){ return this->y; }
private:
    float x;
    float y;
};

class Odcinek{
public:
    Odcinek(const Punkt& p1, const Punkt& p2) : p1(p1), p2(p2) {}
    Punkt zwrocP1(){ return this->p1; }
    Punkt zwrocP2(){ return this->p2; }
private:
    Punkt p1;
    Punkt p2;
};

class Figura{
public:
    void wypiszKrawedzie(){
        std::cout << "Wspolrzedne krawedzi figury: " << this->nazwa << "\n";
        for(unsigned i=0;i<this->odcinki.size();i++)
            std::cout << "K[" << i + 1 << "] = (" << this->odcinki[i].zwrocP1().zwrocX() <<
            ", " << this->odcinki[i].zwrocP1().zwrocY() << "), (" << this->odcinki[i].zwrocP2().zwrocX() <<
            ", " << this->odcinki[i].zwrocP2().zwrocY() << ")\n";
    }

protected:
    std::vector<Odcinek> odcinki;
    std::string nazwa;
};

class Trojkat : public Figura{
public:
    Trojkat(const Odcinek& a, const Odcinek& b, const Odcinek& c, std::string nazwa){
        this->odcinki.push_back(a);
        this->odcinki.push_back(b);
        this->odcinki.push_back(c);
        this->nazwa = nazwa;
    }
};

class Kwadrat : public Figura{
public:
    Kwadrat(const Odcinek& a, const Odcinek& b, const Odcinek& c, const Odcinek& d, std::string nazwa){
        this->odcinki.push_back(a);
        this->odcinki.push_back(b);
        this->odcinki.push_back(c);
        this->odcinki.push_back(d);
        this->nazwa = nazwa;
    }
};

template<class T> class Lista{
public:
    void dodaj(const T &figura){ this->listaFigur.push_back(figura); }
    void wypisz(){
        typename std::list<T>::iterator it;
        for(it=this->listaFigur.begin();it!=this->listaFigur.end();++it){
            std::cout << std::endl;
            (*it)->wypiszKrawedzie();
        }
    }

private:
    std::list<T> listaFigur;
};

int main(){

    Trojkat *trk = new Trojkat(
                Odcinek(Punkt(0,0), Punkt(0,2)),
                Odcinek(Punkt(0,2), Punkt(2,0)),
                Odcinek(Punkt(2,0), Punkt(0,0)),
                "Trojkat");

    Kwadrat *kwd = new Kwadrat(
                Odcinek(Punkt(0,0), Punkt(0,2)),
                Odcinek(Punkt(0,2), Punkt(2,2)),
                Odcinek(Punkt(2,2), Punkt(2,0)),
                Odcinek(Punkt(2,0), Punkt(0,0)),
                "Kwadrat");

    Lista<Figura*> lst;
    lst.dodaj(trk);
    lst.dodaj(kwd);
    lst.wypisz();

    delete trk;
    delete kwd;
    return 0;
}