(C++) Определить класс PolyObjectNumber

[Warrvin]

Определить класс PolyObjectNumber, содержащий поле массива точек с координатами(X, Y). Все методы работают только с одним или двумя объектами (не массивом), если они не статические (static). Попытался сам, но все не получается, затрудняет, что поля класса являются статическими и из-за это не понимаю как написать конструкторы
Вот что получилось написать:

class PolyObjectNumber {
private:
	static double* x, *y;
	static int size_point;
public:
	// Конструкторы 
	PolyObjectNumber() { size_point = 0; } 
	PolyObjectNumber(const int& amount) { // Параметр 
		size_point = amount;
		x = new double[size_point];
		y = new double[size_point];
	}
	PolyObjectNumber(const PolyObjectNumber& copy) { // Копирования 
		size_point = copy.size_point;
		x = copy.x;
		y = copy.y;
	}
	// Диструктор 
	~PolyObjectNumber()
	{
		delete[] x;
		delete[] y;
	}
	// Вспомогательный метод 
	static double frand(double min, double max) {
		double f = (double)rand() / RAND_MAX;
		return min + f * (max - min);
	}
	// Операции ввода-вывода
	friend ostream& operator << (ostream& stream, const PolyObjectNumber poly) {
		return poly.Print(stream);
	}
	friend istream& operator >> (istream& stream, PolyObjectNumber poly) {
		stream >> poly.size_point;
		for (int i = 0; i < poly.size_point; i++) {
			stream >> poly.x[i] >> poly.y[i];
		}
		return stream;
	}

	ostream& Print(ostream& stream) const {
		stream << right;
		stream << "Всего точек в фигуре: " << size_point << ", ";
		for (int i = 0; i < size_point; i++) {
			stream << "Точка № " << i + 1 << ": ";
			stream << "(X;Y) =" << x[i] << ", " << y[i] << "\n";
		};
		return stream;
	}
	
	// Перегрузка операций
	friend PolyObjectNumber& operator ++(PolyObjectNumber& poly) {
		for (int i = 0; i < poly.size_point; i++) {
			poly.x[i]++;
			poly.y[i]++;
		}
		return poly;
	}
	PolyObjectNumber operator ++(int) {
		PolyObjectNumber poly_object_number;
		poly_object_number = *this;
		++(*this);
		return poly_object_number;
	}
	PolyObjectNumber operator *(const double& num) {
		for (int i = 0; i < size_point; i++) {
			x[i] = x[i] * num;
			y[i] = y[i] * num;
		}
		return *this;
	}

	static double perimeter()  {
		double perimeter = 0;
		for (int i = 1; i < size_point; i++) {
			perimeter = perimeter + sqrt(pow(x[i] - x[i - 1], 2) + pow(y[i] - y[i - 1], 2));
		}
		perimeter = perimeter + sqrt(pow(x[size_point] - x[0], 2) + pow(y[size_point] - y[0], 2));
		return perimeter;
	};
	static void generate_value(double min, double max, int rand_max) {
		size_point = rand() / rand_max;
		for (int i = 0; i < size_point; i++) {
			x[i] = frand(min, max);
			y[i] = frand(min, max);

		}
	}
	// Операции сравнения 
	bool operator >(const PolyObjectNumber& poly) const {
		return (*this).perimeter() > poly.perimeter();
	}
	bool operator <(const PolyObjectNumber& poly) const {
		return  (*this).perimeter() < poly.perimeter();
	}

	static void sort(PolyObjectNumber* poly, int quantity)  {
		bool can_changed = true;
		while (can_changed) {
			can_changed = false;
			for (int i = 0; i < quantity - 1; i++) {
				if (poly[i] > poly[i + 1]) {
					swap(poly[i], poly[i + 1]);
					can_changed = true;
				}
			}
		}
	}

};

[ForenLi]

А с чего вы взяли статичность полей?

[Warrvin]

ForenLi, Статические методы класса не могут пользоваться нестатическими
элементами класса. Поэтому я подумал что и сами поля тоже должны быть static

[ForenLi]

Но статическим методам можно передавать параметры. Например, массивы x, y...

[Алексей1153]

del

а, всё, понял. Я не там посмотрел )

Но всё равно всё это странно

[Алексей1153]

ок, частично исправил, дальше сам )

#include <iostream>
#include <vector>
#include <cmath>

struct s_point
{
    double x{};
    double y{};
    
    // Операции ввода-вывода
    friend std::ostream& operator << (std::ostream& stream, const s_point& p)
    {
        stream << p.x;
        stream << p.y;
        return stream;
    }
    
    friend std::istream& operator >> (std::istream& stream, s_point& p)
    {
        stream >> p.x;
        stream >> p.y;
        return stream;
    }
    
    s_point& operator ++()
    {
        x++;
        y++;
        return *this;
    }
    s_point operator ++(int)
    {
        s_point temp{*this};
        ++(*this);
        return temp;
    }
    s_point& operator *=(const double& num)
    {
        x*=num;
        y*=num;
        return *this;
    }
};

class PolyObjectNumber:public std::vector<s_point>
{
public:
    using std::vector<s_point>::vector;

    // Операции ввода-вывода
    friend std::ostream& operator << (std::ostream& stream, const PolyObjectNumber& poly)
    {
        const size_t size=poly.size();
    	stream << size;
    	for(auto& p:poly)
    	{
    		stream << p;
    	}
    
    	return stream;
    }
    
    friend std::istream& operator >> (std::istream& stream, PolyObjectNumber& poly)
    {
        poly={};
        size_t size{};
    	stream >> size;
    	
    	try
    	{
    	    poly.reserve(size);
    	}
    	catch(...)
    	{
    	    poly.clear();
    	    return stream;
    	}
    	
    	for (size_t i = 0; i < size; i++)
    	{
    	    s_point p;
    		if(stream >> p)
    		{
    		    poly.emplace_back(p);
    		}
    	}
    	return stream;
    }
    
    void Print() const
    {
    	std::cout << "Всего точек в фигуре: " << size() << ", ";
    	size_t i{};
    	for (auto& p:*this)
    	{
    		std::cout << "Точка № " << i + 1 << ": ";
    		std::cout << "(X;Y) =" << p.x << ", " << p.y << "\n";
    	};
    }
    
    PolyObjectNumber& operator ++()
    {
    	for(auto& p:*this)p++;
    	return *this;
    }
    PolyObjectNumber operator ++(int)
    {
    	PolyObjectNumber temp{*this};
    	++(*this);
    	return temp;
    }
    PolyObjectNumber& operator *=(const double& num)
    {
    	for(auto& p:*this)p*=num;
    	return *this;
    }
    
    double perimeter()const
    {
    	double perimeter = 0;
    	if(!size())return perimeter;
    	
    	auto summ=[&perimeter](const auto& p1, const auto& p2)
    	{
    	    const auto dx=p1.x-p2.x;
    	    const auto dy=p1.y-p2.y;
    		perimeter += std::sqrt(dx*dx+dy*dy);
    	};
    	
    	for (size_t i = 1; i < size(); i++)
    	{
    	    summ(at(i), at(i - 1));
    	}
    	
        summ(*rbegin(), *begin());
    
    	return perimeter;
    };
    /*
    // Вспомогательный метод 
    static double frand(double min, double max) {
    	double f = (double)rand() / RAND_MAX;
    	return min + f * (max - min);
    }
    
    static void generate_value(double min, double max, int rand_max) {
    	size_point = rand() / rand_max;
    	for (int i = 0; i < size_point; i++) {
    		x[i] = frand(min, max);
    		y[i] = frand(min, max);
    	}
    }
    // Операции сравнения 
    bool operator >(const PolyObjectNumber& poly) const {
    	return (*this).perimeter() > poly.perimeter();
    }
    bool operator <(const PolyObjectNumber& poly) const {
    	return  (*this).perimeter() < poly.perimeter();
    }
    
    static void sort(PolyObjectNumber* poly, int quantity)  {
    	bool can_changed = true;
    	while (can_changed) {
    		can_changed = false;
    		for (int i = 0; i < quantity - 1; i++) {
    			if (poly[i] > poly[i + 1]) {
    				swap(poly[i], poly[i + 1]);
    				can_changed = true;
    			}
    		}
    	}
    }*/
};

int main()
{
    PolyObjectNumber p{{1,1},{2,2},{3,3},{4,4},{5,5}};
    p.Print();
    
    p++;
    p.Print();

    ++p;
    p.Print();

    p*=10;
    p.Print();
}