• Гідрологія і Гідрометрія
• Господарське право
• Економіка будівництва
• Економіка природокористування
• Економічна теорія
• Земельне право
• Історія України
• Кримінально виконавче право
• Медична радіологія
• Методи аналізу
• Міжнародне приватне право
• Міжнародний маркетинг
• Основи екології
• Предмет Політологія
• Соціальне страхування
• Технічні засоби організації дорожнього руху
• Товарознавство продовольчих товарів

Тлумачний словник
Авто
Автоматизація
Архітектура
Астрономія
Аудит
Біологія
Будівництво
Бухгалтерія
Винахідництво
Виробництво
Військова справа
Генетика
Географія
Геологія
Господарство
Держава
Дім
Екологія
Економетрика
Економіка
Електроніка
Журналістика та ЗМІ
Зв'язок
Іноземні мови
Інформатика
Історія
Комп'ютери
Креслення
Кулінарія
Культура
Лексикологія
Література
Логіка
Маркетинг
Математика
Машинобудування
Медицина
Менеджмент
Метали і Зварювання
Механіка
Мистецтво
Музика
Населення
Освіта
Охорона безпеки життя
Охорона Праці
Педагогіка
Політика
Право
Програмування
Промисловість
Психологія
Радіо
Регилия
Соціологія
Спорт
Стандартизація
Технології
Торгівля
Туризм
Фізика
Фізіологія
Філософія
Фінанси
Хімія
Юриспунденкция

Shapes.h

#ifndef SHAPES_H

#define SHAPES_H

#include <stdexcept>

#include <valarray>

#include <algorithm>

////////////////////////////////////////////////////////////////////////////////

template< typename T >

static double bounded(T value, T minValue, T maxValue)

{

return std::min(std::max(value, minValue), maxValue);

}

template< typename T >

static double bounded(T value, T maxValue = 0.)

{

return bounded(value, 0., maxValue);

}

////////////////////////////////////////////////////////////////////////////////

struct ColorChannel

{

static const double maxValue = 1.;

ColorChannel(double value = 0);

operator double() const;

ColorChannel& operator = (double value);

// ...

private:

double value;

};

struct Color

{

ColorChannel red, green, blue, alpha;

Color(ColorChannel red, ColorChannel green, ColorChannel blue,

ColorChannel alpha = 1.);

static const Color blackColor;

static const Color whiteColor;

static const Color grayColor;

};

struct DrawStyle

{

Color lineColor, fillColor;

DrawStyle(Color lineColor = Color::blackColor,

Color fillColor = Color::grayColor);

};

////////////////////////////////////////////////////////////////////////////////

template< typename T, size_t D >

struct Vector

{

Vector (const T& value = 0);

Vector< T, D >& operator += (const Vector< T, D >& value);

Vector< T, D >& operator -= (const Vector< T, D >& value);

Vector< T, D >& operator *= (const T& value);

// ...

const T& operator [] (size_t dimension) const throw (std::out_of_range);

T& operator [] (size_t dimension) throw (std::out_of_range);

Vector< T, D >& makePositive();

private:

std::valarray< T > data;

};

template< typename T, size_t D >

Vector< T, D > operator + (const Vector< T, D >& left, const Vector< T, D >& right);

template< typename T, size_t D >

Vector< T, D > operator - (const Vector< T, D >& left, const Vector< T, D >& right);

template< typename T, size_t D >

Vector< T, D > operator * (const Vector< T, D >& left, const T& value);

////////////////////////////////////////////////////////////////////////////////

template< typename T, size_t D >

Vector< T, D >::Vector (const T& value)

: data(value, D)

{}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::makePositive()

{

data = abs(data);

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator += (const Vector< T, D >& value)

{

data += value.data;

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator -= (const Vector< T, D >& value)

{

data -= value.data;

return *this;

}

template< typename T, size_t D >

Vector< T, D >& Vector< T, D >::operator *= (const T& value)

{

data *= value;

return *this;

}

template< typename T, size_t D >

T& Vector< T, D >::operator [] (size_t dimension) throw (std::out_of_range)

{

if (dimension > D - 1) throw std::out_of_range("dimension error");

return data[dimension];

}

template< typename T, size_t D >

const T& Vector< T, D >::operator [] (size_t dimension) const throw (std::out_of_range)

{

return data[dimension];

}

template< typename T, size_t D >

Vector< T, D > operator + (const Vector< T, D >& left, const Vector< T, D >& right)

{

Vector< T, D > res(left);

res += right;

return res;

}

template< typename T, size_t D >

Vector< T, D > operator - (const Vector< T, D >& left, const Vector< T, D >& right)

{

Vector< T, D > res(left);

res -= right;

return res;

}

template< typename T, size_t D >

Vector< T, D > operator * (const Vector< T, D >& left, const T& right)

{

Vector< T, D > res(left);

res *= right;

return res;

}

typedef double Coord;

typedef Vector< Coord, 2 > Vector2D;

#define X 0

#define Y 1

////////////////////////////////////////////////////////////////////////////////

class Figure

{

public:

virtual ~Figure();

virtual DrawStyle& getStyle();

virtual const DrawStyle& getStyle() const;

protected:

DrawStyle style;

};

template < typename T >

class Shape: public Figure

{

public:

virtual T getCenter() const { return center; }

virtual T getSize() const { return size; }

virtual void setBounds(const T& p1, const T& p2) = 0;

virtual void move(const T& destination) = 0;

virtual bool belongs(const T& point) = 0;

protected:

T center;

T size;

};

typedef Shape< Vector2D > Shape2D;

class Rectangle: public Shape2D

{

public:

Rectangle(const Vector2D& p1, const Vector2D& p2);

virtual void setBounds(const Vector2D& p1, const Vector2D& p2);

virtual void move(const Vector2D& destination);

virtual bool belongs(const Vector2D& point);

};

#endif

Переглядів: 295