Полиморфизм, Точка в трёхмерном пространстве

#include <conio.h>
//Задание 1 "Точка в трёхмерном пространстве".
class Point {
    float x,y,z; //координаты точки
    char colour[n]; //цвет
public: 
    Point() { //Конструктор по умолчанию.
            x=y=z=0;
            //char colour[9] = "white";
        }
     // Конструктор для Point.
        Point(float a, float b, float c) {
            x = a;
            y = b;
            z = c;
        }
     void print() //Вводим координаты точки.
    {
    printf("\nВведите координаты\n");
    
    scanf("%f", &x);
    printf("\n");
    scanf("%f", &y);
    printf("\n");
    scanf("%f", &z);
    printf("\n");
    }
 
    void input()  //Выводим координаты точки на экран.
    {
        printf("\nКоординаты точки:\n");
        printf("%4.0f",x);
        printf("\n");
        printf("%4.0f",y);
        printf("\n");
        printf("%4.0f",z);
        printf("\n");
    }
    int rast()
    {
        return (sqrt(y*y+x*x))+z*z;
    }
};
//Задание 2 "Материальная точка".
class Point_M: public Point {
    int m; //собственное данное - масса.
public:
    Point_M(){ //конструктор по умолчанию.
    m = 0;}
    Point_M(int S){//конструктор с параметром.
    m = S; }
bool compare(int c1, int c2){ //метод для сравнения масс точек.
    if (c1 > c2)
    return 1;
    else return 0;
}
 
};

...
bool compare(Point_M& other){ //метод для сравнения масс точек.
    if (this->m > other->m)
    return 1;
    else return 0;

#include <cstdlib>
#include <ctime>
#include <cmath>
#include <cstring>
#include <iostream>
#include <iomanip>
 
class Color {
 public:
  Color(int red, int green, int blue) : red(red), green(green), blue(blue) {}
  int getRed() const { return red; }
  int getGreen() const { return green; }
  int getBlue() const { return blue; }
 private:
  int red, green, blue;
};
 
std::ostream &operator<<(std::ostream &stream, const Color &color) {
  return stream << "Color{" <<
    "red=" << color.getRed() << "," <<
    "green=" << color.getGreen() << "," <<
    "blue=" << color.getBlue() << "}";
}
 
class Point {
 public:
  Point() : x(0), y(0), z(0), color(0, 0, 0) {}
  explicit Point(int maxRandom) : x(rand() % maxRandom), y(rand() % maxRandom),
    z(rand() % maxRandom), color(0, 0, 0) {}
  Point(int x, int y, int z, const Color &color) : x(x), y(y), z(z),
    color(color) {}
  Point(int x, int y, int z) : x(x), y(y), z(z), color(0, 0, 0) {}
  int getX() const { return x; }
  int getY() const { return y; }
  int getZ() const { return z; }
  const Color &getColor() const { return color; }
  double getDistanceTo(int x, int y, int z) {
    return sqrt(pow(x - getX(), 2.0) + pow(y - getY(), 2.0) +
      pow(z - getZ(), 2.0));
  }
  double getDistanceTo(const Point &other) {
    return getDistanceTo(other.getX(), other.getY(), other.getZ());
  }
 private:
  int x, y, z;
  Color color;  
};
 
std::ostream &operator<<(std::ostream &stream, const Point &point) {
  return stream << "Point{" <<
    "x=" << point.getX() << "," <<
    "y=" << point.getY() << "," <<
    "z=" << point.getZ() << "," <<
    "color=" << point.getColor() << "}";
}
 
class MassPoint : public Point {
 public:
  MassPoint() : Point() {}
  explicit MassPoint(int maxRandom) : Point(maxRandom),
    mass(rand() % maxRandom) {}
  MassPoint(int x, int y, int z, const Color &color, int mass)
    : Point(x, y, z, color), mass(mass) {}
  MassPoint(int x, int y, int z, int mass) : Point(x, y, z), mass(mass) {}
  int getMass() const { return mass; }
  int compareByMass(const MassPoint &other) const {
    return getMass() - other.getMass();
  }
  static int compareByMass(const MassPoint &a, const MassPoint &b) {
    return a.compareByMass(b);
  }
 private:
  int mass;
};
 
std::ostream &operator<<(std::ostream &stream, const MassPoint &point) {
  return stream << "MassPoint{" <<
    "x=" << point.getX() << "," <<
    "y=" << point.getY() << "," <<
    "z=" << point.getZ() << "," <<
    "color=" << point.getColor() << "," <<
    "mass=" << point.getMass() << "}";
}
 
MassPoint *getMax(MassPoint *begin, MassPoint *end,
  int (*comparator)(const MassPoint &a, const MassPoint &b)) {
  MassPoint *result = begin++;
  while (begin != end) {
    if (comparator(*result, *begin) < 0) {
      result = begin;
    }
    ++begin;
  }
  return result;
}
 
int main(int argc, char *argv[]) {
  srand(time(0));
 
  Point origin(0, 0, 0);
  std::cout << "ORIGIN POINT: " << origin << std::endl;
 
  const int numberOfPoints = 10;
  MassPoint points[numberOfPoints];
  
  for (int i = 0; i < numberOfPoints; ++i) {
    points[i] = MassPoint(20); // òî÷êà ñî ñëó÷àéíûìè êîîðäèíàòàìè
    std::cout << points[i] << " distance to origin is " <<
      std::fixed << std::setprecision(3) <<
      points[i].getDistanceTo(origin) << std::endl;
  }
  
  std::cout << "MAX MASS POINT " << *getMax(points, points + numberOfPoints,
    MassPoint::compareByMass);
 
  std::cin.peek();
  return 0;
}