Нужно создать иерархию классов с использованием подражания (Наследование)С++

#include <iostream>
 
// отсюда можно код убрать в Point.h
#include <cmath>
#include <iomanip>
 
struct Point {
    const double x;
    const double y;
    const double z;
};
 
Point move(const Point &p, const Point &delta) {
    return {p.x + delta.x, p.y + delta.y, p.z + delta.z};
}
 
double distance(const Point &a, const Point &b) {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    double dz = a.z - b.z;
    return std::sqrt(dx * dx + dy * dy + dz * dz);
}
 
Point middle(const Point &a, const Point &b) {
    return {(a.x + b.x) / 2., (a.y + b.y) / 2., (a.z + b.z) / 2.};
}
 
std::ostream &operator<<(std::ostream &out, const Point &p) {
    return out << std::fixed << std::setprecision(2) << "[" << p.x << ", " << p.y << ", " << p.z << "]";
}
 
// посюда
 
// отсюда можно код убрать в файл Quadrilateral.h
// раскоментировав инклуд пойнта:
// #include "Point.h"
 
struct Quadrilateral {
    const Point a;
    const Point b;
    const Point c;
    const Point d;
};
 
std::ostream &operator<<(std::ostream &out, const Quadrilateral &q) {
    return out << "Quadrilateral{" <<
               "a=" << q.a << ", b=" << q.b << ", c=" << q.c << ", d=" << q.d << "}";
}
 
Quadrilateral move(const Quadrilateral &q, const Point &p) {
    double dx = p.x - q.a.x;
    double dy = p.y - q.a.y;
    double dz = p.z - q.a.z;
    return Quadrilateral{
            move(q.a, {dx, dy, dz}),
            move(q.b, {dx, dy, dz}),
            move(q.c, {dx, dy, dz}),
            move(q.d, {dx, dy, dz})
    };
}
 
double epsilon = 0.000001;
 
bool isParallelogram(const Quadrilateral &q) {
    double ab = distance(q.a, q.b);
    double cd = distance(q.c, q.d);
    if (std::fabs(ab - cd) >= epsilon) {
        return false;
    }
 
    double bc = distance(q.b, q.c);
    double da = distance(q.d, q.a);
    if (std::fabs(bc - da) >= epsilon) {
        return false;
    }
 
    Point mac = middle(q.a, q.c);
    Point mbd = middle(q.b, q.d);
 
    return std::fabs(mac.x - mbd.x) < epsilon ||
           std::fabs(mac.y - mbd.y) < epsilon ||
           std::fabs(mac.z - mbd.z) < epsilon;
}
 
// посюда
 
// отсюда можно код убрать в файл Parallelepiped.h
// раскоментировав инклуд пойнта и четырехугольника:
// #include "Point.h"
// #include "Quadrilateral.h"
 
struct Parallelepiped {
    const Quadrilateral a;
    const Quadrilateral b;
 
    Parallelepiped(const Quadrilateral &base, const Point &top) : a(base), b(move(base, top)) {
        if (!isParallelogram(base)) {
            throw std::invalid_argument("quadrangle must be a parallelogram");
        }
    }
};
 
std::ostream &operator<<(std::ostream &out, const Parallelepiped &p) {
    return out << "Parallelepiped{" << "a=" << p.a << ", b=" << p.b << "}";
}
 
// посюда
// тут можно включить инклуд параллелепипеда, чтоб заработало
//#include "Parallelepiped.h"
 
int main() {
    Quadrilateral q{{0, 0, 0},
                    {0, 1, 0},
                    {1, 0, 0},
                    {1, 1, 0}};
 
    Parallelepiped p{q, {1, 1, 1}};
 
    std::cout << p << std::endl;
 
    return 0;
}