Простейшая композиция по значению

 

Ниже представлен класс для точки в 3-х мерном пространстве:

 

point3d.hpp

 

#ifndef _POINT3D_HPP_

#define _POINT3D_HPP_

 

//************************************************************************

 

class Point3D

{

 

/*-----------------------------------------------------------------*/

 

public:

 

/*-----------------------------------------------------------------*/

 

// Конструктор по умолчанию – задает начало координат

Point3D ();

 

// Конструктор с аргументами — задает конкретные значения координат

Point3D (double _x, double _y, double _z);

 

// Методы доступа к координатам

double getX () const;

double getY () const;

double getZ () const;

 

// Метод вычисления расстояния до другой точки

double distanceTo (Point3D _p) const;

 

// Перегруженные операторы сравнения на равенство и неравенство

bool operator == (Point3D _p) const;

bool operator!= (Point3D _p) const;

 

/*-----------------------------------------------------------------*/

 

private:

 

/*-----------------------------------------------------------------*/

 

// Координаты точки по каждой из осей

double m_x, m_y, m_z;

};

 

//************************************************************************

 

// Метод доступа к координате по оси абсцисс

inline double Point3D::getX () const

{

return m_x;

}

 

//************************************************************************

 

// Метод доступа к координате по оси ординат

inline double Point3D::getY () const

{

return m_y;

}

 

//************************************************************************

 

// Метод доступа к координате по оси аппликат

inline double Point3D::getZ () const

{

return m_z;

}

 

//************************************************************************

 

#endif // _POINT3D_HPP

 

 

point3d.cpp

 

#include "point3d.hpp"

#include <cmath>

 

//************************************************************************

 

// Реализация конструктора по умолчанию

Point3D::Point3D ()

:m_x(0.0), m_y(0.0), m_z(0.0)

{

}

 

//************************************************************************

 

// Реализация конструктора с аргументами

Point3D::Point3D (double _x, double _y, double _z)

:m_x(_x), m_y(_y), m_z(_z)

{

}

 

//************************************************************************

 

// Реализация метода вычисления расстояния до другой дочки

double Point3D::distanceTo (Point3D _p) const

{

double xDiff = _p.getX() - getX();

double yDiff = _p.getY() - getY();

double zDiff = _p.getZ() - getZ();

return sqrt(xDiff * xDiff + yDiff * yDiff + zDiff * zDiff);

}

 

//************************************************************************

 

// Реализация оператора сравнения на равенство

bool Point3D:: operator == (Point3D _p) const

{

return getX() == _p.getX() &&

getY() == _p.getY() &&

getZ() == _p.getZ();

}

 

//************************************************************************

 

// Реализация оператора сравнения на равенство

bool Point3D:: operator!= (Point3D _p) const

{

return!(* this == _p);

}

 

//************************************************************************

 

Класс для окружности использует реализованный выше класс для точки для дочернего объекта, означающего координаты центра. Точка хранится в окружности по значению и не может быть отделена от окружности:

 

 

circle.hpp

 

#ifndef _CIRCLE_HPP_

#define _CIRCLE_HPP_

 

//************************************************************************

 

#include "point3d.hpp"

 

//************************************************************************

 

class Circle

{

/*-----------------------------------------------------------------*/

 

public:

 

/*-----------------------------------------------------------------*/

 

// Конструктор

Circle (Point3D _center, double _radius);

 

// Метод доступа к координатам центра

Point3D getCenter () const;

 

// Метод доступа к радиусу

double getRadius () const;

 

// Метод вычисления длины окружности

double getPerimeter () const;

 

// Метод вычисления площади окружности

double getArea () const;

 

// Метод вычисления координаты точки на окружности под определенным углом

Point3D getPointOn (double _angle) const;

 

/*-----------------------------------------------------------------*/

 

private:

 

/*-----------------------------------------------------------------*/

 

// Центр окружности — дочерний объект класса Point3D

Point3D m_center;

 

// Радиус окружности

double m_radius;

 

/*-----------------------------------------------------------------*/

 

};

 

//************************************************************************

 

// Реализация метода доступа к координатам центра

inline Point3D

Circle::getCenter () const

{

return m_center;

}

 

//************************************************************************

 

// Реализация метода доступа к радиусу

Inline double

Circle::getRadius () const

{

return m_radius;

}

 

//************************************************************************

 

#endif // _CIRCLE_HPP_

 

 

circle.cpp

 

#include "circle.hpp"

 

#define _USE_MATH_DEFINES // <- необходимо для работы с константой M_PI

#include <cmath>

 

#include <stdexcept>

 

//************************************************************************

 

// Реализация конструктора

Circle::Circle (Point3D _center, double _radius)

: m_center(_center) // <= вызов конструктора копий Point3D

, m_radius(_radius)

{

// Инвариант: радиус должен быть положительным

if (m_radius <= 0.0)

throw std::logic_error("Circle radius must be positive");

}

 

//************************************************************************

 

// Реализация метода вычисления длины окружности

double Circle::getPerimeter () const

{

return 2.0 * M_PI * m_radius;

}

 

//************************************************************************

 

// Реализация метода вычисления площади окружности

double Circle::getArea () const

{

return M_PI * m_radius * m_radius;

}

 

//************************************************************************

 

// Реализация метода вычисления координат точки на окружности под заданным углом

Point3D Circle::getPointOn (double _angle) const

{

// Вычисляем длины катетов по гипотенузе (радиусу) и углу

double xOffset = m_radius * cos(_angle);

double yOffset = m_radius * sin(_angle);

 

// Создаем новый объект-точку

return Point3D(m_center.getX() + xOffset,

m_center.getY() + yOffset,

m_center.getZ()

);

}

 

//************************************************************************

 

В свою очередь, класс-цилиндр использует в качестве дочернего объекта окружности для моделирования основания. Аналогично предыдущему случаю, дочерний объект-окружность хранится в объекте-цилиндре по значению. А значит внутри объекта-цилиндра есть и объект-точка, представляющая собой центр окружности-основания:

 

 

cylinder.hpp

 

#ifndef _CYLINDER_HPP_

#define _CYLINDER_HPP_

 

//************************************************************************

 

#include " circle.hpp"

 

//************************************************************************

 

class Cylinder

{

/*-----------------------------------------------------------------*/

 

public:

 

/*-----------------------------------------------------------------*/

 

// Конструктор. Передаем основание по ссылке.

// Передача основания по значению также допустима.

Cylinder (Circle _base, double _height);

 

// Метод доступа к объекту-основанию

Circle getBase () const;

 

// Метод доступа к высоте цилиндра

double getHeight () const;

 

// Метод вычисления объема цилиндра

double getVolume () const;

 

// Метод вычисления площади поверхности сторон

double getSideSurfaceArea () const;

 

// Метод вычисления всей площади поверхности

double getFullSurfaceArea () const;

 

// Метод вычисления координат точки на поверхности под определенным углом

// и на заданной высоте

Point3D getPointOnSurface (double _angle, double _height) const;

 

/*-----------------------------------------------------------------*/

 

private:

 

/*-----------------------------------------------------------------*/

 

// Основание цилиндра — дочерний объект класса Circle

Circle m_base;

 

// Высота цилиндра

double m_height;

 

/*-----------------------------------------------------------------*/

 

};

 

//************************************************************************

 

// Реализация метода доступа к объекту-основания

inline Circle

Cylinder::getBase () const

{

return m_base;

}

 

//************************************************************************

 

// Реализация метода доступа к высоте

Inline double

Cylinder::getHeight () const

{

return m_height;

}

 

//************************************************************************

 

#endif // _CYLINDER_HPP_

 

 

cylinder.cpp

 

//************************************************************************

 

#include "cylinder.hpp"

#include <cmath>

#include <stdexcept>

 

//************************************************************************

 

// Реализация конструктора

Cylinder::Cylinder (const Circle & _base, double _height)

: m_base(_base) // <= вызов конструктора копий класса Circle

, m_height(_height)

{

// Инвариант: высота должна быть положительной

if (m_height <= 0.0)

throw std::logic_error("Cylinder height must be positive");

}

 

//************************************************************************

 

// Реализация метода вычисления объема

double Cylinder::getVolume () const

{

return m_base.getArea() * m_height;

}

 

//************************************************************************

 

// Реализация метода вычисления площади поверхности сторон

double Cylinder::getSideSurfaceArea () const

{

return m_base.getPerimeter() * m_height;

}

 

//************************************************************************

 

// Реализация метода вычисления площади полной поверхности

double Cylinder::getFullSurfaceArea () const

{

return getSideSurfaceArea() + 2.0 * m_base.getArea();

}

 

//************************************************************************

 

// Реализация метода вычисления координат точки на поверхности

Point3D Cylinder::getPointOnSurface (double _angle, double _height) const

{

// Вычисляем координаты точки на основании

Point3D circlePoint = m_base.getPointOn(_angle);

 

// Создаем новую точку с учетом высоты

return Point3D(circlePoint.getX(),
circlePoint.getY(),
circlePoint.getZ() + _height);

}

 

//************************************************************************