std::sort

#include <iostream>
#include <fstream>
enum E_COLOR { RED, GREEN, BLUE, WHITE };
 
class Shape {
    E_COLOR color;
public:
    Shape(E_COLOR color = RED);
    virtual double Area() const = 0;
    virtual Shape* Copy() const = 0;
    virtual bool operator==(const Shape&) const = 0;
    virtual Shape& operator=(const Shape&);
    int getColor() const;
    friend std::ostream& operator<<(std::ostream& of, const Shape&);
    friend std::ofstream& operator<<(std::ofstream& of, const Shape&);
};

#include "Shape.h"
 
Shape::Shape(E_COLOR color):color(color) {
}
 
bool Shape::operator==(const Shape& other) const  {
    return this->color == other.color ? true : false;
}
 
int Shape::getColor() const {
    return this->color;
}
 
Shape& Shape::operator=(const Shape& other){
    color = other.color;
    return *this;
}
 
std::ostream& operator<<(std::ostream& of, const Shape& other) {
    const char* ar[] = { "RED", "GREEN", "BLUE", "WHITE" };
    std::cout << "Color - " << ar[other.color] << std::endl;
    return of;
}
 
std::ofstream& operator<<(std::ofstream& of, const Shape& shape) {
    of << static_cast<int>(shape.color) << std::endl;
    return of;
}

#include "Shape.h"
#include "fstream"
 
class Rect:public Shape {
    int xl;
    int yl;
    int xr;
    int yr;
public:
    Shape* Copy() const;
    Rect();
    Rect(int, int, int, int,  E_COLOR);
    double Area()const;
    virtual bool operator==(const Shape&) const;
    virtual Rect& operator=(const Shape&);
    friend std::ostream& operator<<(std::ostream& of, const Rect& other);
    friend std::ofstream& operator<<(std::ofstream& of, const Rect&);
    friend class Distance;
};

#include "Rect.h"
 
Rect::Rect() {
    xl = 0;
    yl = 0;
    xr = 0;
    yl= 0;
}
 
Rect::Rect(int x, int y, int x1, int y1, E_COLOR col):Shape(col){
    xl = x;
    yl = y;
    xr = x1;
    yr = y1;
}
 
double Rect::Area() const {
    return (xr - xl) * (yr - yl);
}
 
Shape* Rect::Copy() const {
    return new Rect(*this);
}
 
Rect& Rect::operator=(const Shape& other) {
    const Rect& c = static_cast<const Rect&>(other);
    *this = c;
    return *this;
}
 
bool Rect::operator==(const Shape& other) const {
    if (typeid(other) == typeid(Rect)) {
        const Rect& c = static_cast<const Rect&>(other);
        return this->xr == c.xr && this->xl == c.xl && this->yl == c.yl && this->yr == c.yr  && (this->Shape::operator==(other));
    }
    else return false;
}
 
std::ostream& operator<<(std::ostream& of, const Rect& other) {
    std::cout << "Its RECT\nxl=" << other.xl << " yl=" << other.yl << " xr=" << other.xr << " yr=" << other.yr << std::endl;
    return of;
}
 
std::ofstream& operator<<(std::ofstream& of, const Rect& rect) {
    of << rect.xl << std::endl;
    of << rect.yl << std::endl;
    of << rect.xr << std::endl;
    of << rect.yr << std::endl;
    return of;
}

#include <cmath>
class Distance {
    int x;
    int y;
public:
    Distance(int first, int second) :x(first), y(second) {};
    bool operator()(const Rect& rect1, const Rect& rect2)const {
        return (pow((((rect1.xr - rect1.xl)/2) - x), 2) + pow((((rect1.yr - rect1.yl)/2)-y), 2)) > 
            (pow((((rect2.xr - rect2.xl) / 2) - x), 2) + pow((((rect2.yr - rect2.yl) / 2) - y), 2)); //ТЕОРЕМА ПИФАГОРА
    }
};

#include <iostream>
#include <list>
#include <algorithm>
#include "Funcs.h"
#include "Rect.h"
int main(){
std::list<Rect> list_rect;
    list_rect.push_back(Rect(2, 3, 5, 6, GREEN));
    list_rect.push_back(Rect(23, 3, 11, 8, GREEN));
    list_rect.push_back(Rect(13, 27, 8, 9, GREEN));
    list_rect.push_back(Rect(1, 1, 8, 10, GREEN));
    std::sort(list_rect.begin(), list_rect.end(), Distance(0,0));
}

#include <iostream>
#include <list>
#include <algorithm>
#include "Rect.h"
#include "Funcs.h"