Разработать класс "Точка на плоскости"

class Punkt
{
    int x,y;
public:
    void punkt(int x,int y)
    {
        this->x = x;
        this->y = y;
    }
    
    float Rad()
    {
        float r = sqrt(pow(x,2) + pow(y,2));
        return r;
    }
    
    int num()
    {
        if(x > 0 && y > 0) return 1;
        else if(y>0 && x < 0) return 2;
        else if(y < 0 && x < 0) return 3;
        else return 4;
    }
};

#include <iostream>
#include <unordered_map>
#include <cmath>
#include <iomanip>
 
class Point {
public:
    Point(float x, float y) : x(x), y(y) {}
 
    Point() : x(0.f), y(0.f) {}
 
    float getX() const {
        return x;
    }
 
    float getY() const {
        return y;
    }
 
private:
    float x;
    float y;
};
 
float distance(const Point &a, const Point &b) {
    float dx = a.getX() - b.getX();
    float dy = a.getY() - b.getY();
    return std::sqrt(dx * dx + dy * dy);
}
 
enum class Quarter {
    FIRST = 1,
    SECOND = 2,
    THIRD = 4,
    FOURTH = 8,
    FIRST_AND_SECOND = FIRST | SECOND,
    SECOND_AND_THIRD = SECOND | THIRD,
    THIRD_AND_FOURTH = THIRD | FOURTH,
    FOURTH_AND_FIRST = FOURTH | FIRST,
    ALL = FIRST | SECOND | THIRD | FOURTH
};
 
inline static std::unordered_map<Quarter, std::string> QUADRANT_NAMES {
        {Quarter::FIRST, "first"},
        {Quarter::SECOND, "second"},
        {Quarter::THIRD, "third"},
        {Quarter::FOURTH, "fourth"},
        {Quarter::FIRST_AND_SECOND, "on X-axis, first and second"},
        {Quarter::SECOND_AND_THIRD, "on Y-axis, second and third"},
        {Quarter::THIRD_AND_FOURTH, "on X-axis, third and fourth"},
        {Quarter::FOURTH_AND_FIRST, "on Y-axis, fourth and first"},
        {Quarter::ALL, "at the origin"},
};
 
Quarter findQuadrant(const Point &p) {
    Quarter byX = p.getX() > 0 ? Quarter::FOURTH_AND_FIRST : p.getX() < 0 ? Quarter::SECOND_AND_THIRD : Quarter::ALL;
    Quarter byY = p.getY() > 0 ? Quarter::FIRST_AND_SECOND : p.getY() < 0 ? Quarter::THIRD_AND_FOURTH : Quarter::ALL;
    return static_cast<Quarter>(static_cast<int>(byX) & static_cast<int>(byY));
};
 
int main() {
 
    Point ZERO;
 
    for (int i = -1; i < 2; ++i) {
        for (int j = -1; j < 2; ++j) {
            Point point{static_cast<float>(i), static_cast<float>(j)};
            std::cout << std::setw(3) << i << std::setw(3) << j
                << ": distance to (0, 0) = " << std::fixed << std::setprecision(2) << distance(ZERO, point)
                << ", quadrant: " << QUADRANT_NAMES[findQuadrant(point)] << '\n';
        }
    }
 
    return 0;
}