class Base
{
public:
 Base(int i) : i(i) { }
 virtual ~Base() { }
 virtual void func() const {
  std::cout << "Base: " << i << std::endl;
 }
private:
 int i;
};

class Derived : public Base
{
public:
 Derived(int i, int j)
  : Base(i), j(j) { }
 virtual ~Derived() { }
 virtual void func() const override {
  std::cout << "Derived: " << j << std::endl;
 }
private:
 int j;
};

class MyFunction
{
private:
 class FunctorWrapper
 {
 public:
  virtual ~FunctorWrapper() = default;
  virtual FunctorWrapper* clone() const = 0;
  virtual void call() const = 0;
 };
 template<typename T>
 class ConcreteWrapper : public FunctorWrapper
 {
 public:
  ConcreteWrapper(const T& functor)
   : functor(functor) { }
  virtual ~ConcreteWrapper() override = default;
  virtual ConcreteWrapper* clone() const
  {
   return new ConcreteWrapper(*this);
  }
  virtual void call() const override
  {
   functor();
  }
 private:
  T functor;
 };
public:
 MyFunction() = default;
 template<typename T>
 MyFunction(T&& functor)
  : ptr(new ConcreteWrapper<T>(functor)) { }
 MyFunction(const MyFunction& other)
  : ptr(other.ptr->clone()) { }
 MyFunction& operator=(const MyFunction& other)
 {
  if (this != &other)
  {
   delete ptr;
   ptr = other.ptr->clone();
  }
  return *this;
 }
 MyFunction(MyFunction&& other) noexcept
  : ptr(std::exchange(other.ptr, nullptr)) { }
 MyFunction& operator=(MyFunction&& other) noexcept
 {
  if (this != &other)
  {
   delete ptr;
   ptr = std::exchange(other.ptr, nullptr);
  }
  return *this;
 }
 ~MyFunction()
 {
  delete ptr;
 }
 void operator()() const
 {
  if (ptr)
   ptr->call();
 }
 FunctorWrapper* ptr = nullptr;
};

class MyFunction
{
private:
 static constexpr std::size_t size = 16;
 static_assert(size >= sizeof(void*), "");
 struct Data
 {
  Data() = default;
  char dont_use[size];
 } data;
 template<typename T>
 static void functorConstruct(Data& dst, T&& src)
 {
  using U = typename std::decay<T>::type;
  if (sizeof(U) <= size)
   new ((U*)&dst) U(std::forward<U>(src));
  else
   *(U**)&dst = new U(std::forward<U>(src));
 }
 template<typename T>
 static void functorDestructor(Data& data)
 {
  using U = typename std::decay<T>::type;
  if (sizeof(U) <= size)
   ((U*)&data)->~U();
  else
   delete *(U**)&data;
 }
 template<typename T>
 static void functorCopyCtor(Data& dst, const Data& src)
 {
  using U = typename std::decay<T>::type;
  if (sizeof(U) <= size)
   new ((U*)&dst) U(*(const U*)&src);
  else
   *(U**)&dst = new U(**(const U**)&src);
 }
 template<typename T>
 static void functorMoveCtor(Data& dst, Data& src)
 {
  using U = typename std::decay<T>::type;
  if (sizeof(U) <= size)
   new ((U*)&dst) U(*(const U*)&src);
  else
   *(U**)&dst = std::exchange(*(U**)&src, nullptr);
 }
 template<typename T>
 static void functorInvoke(const Data& data)
 {
  using U = typename std::decay<T>::type;
  if (sizeof(U) <= size)
   (*(U*)&data)();
  else
   (**(U**)&data)();
 }
 template<typename T>
 static void (*const vtables[4])();
 void (*const* vtable)() = nullptr;
public:
 MyFunction() = default;
 template<typename T>
 MyFunction(T&& obj)
  : vtable(vtables<T>)
 {
  functorConstruct(data, std::forward<T>(obj));
 }
 MyFunction(const MyFunction& other)
  : vtable(other.vtable)
 {
  if (vtable)
   ((void (*)(Data&, const Data&))vtable[1])(this->data, other.data);
 }
 MyFunction& operator=(const MyFunction& other)
 {
  this->~MyFunction();
  vtable = other.vtable;
  new (this) MyFunction(other);
  return *this;
 }
 MyFunction(MyFunction&& other) noexcept
  : vtable(std::exchange(other.vtable, nullptr))
 {
  if (vtable)
   ((void (*)(Data&, Data&))vtable[2])(this->data, other.data);
 }
 MyFunction& operator=(MyFunction&& other) noexcept
 {
  this->~MyFunction();
  new (this) MyFunction(std::move(other));
  return *this;
 }
 ~MyFunction()
 {
  if (vtable)
   ((void (*)(Data&))vtable[0])(data);
 }
 void operator()() const
 {
  if (vtable)
   ((void (*)(const Data&))vtable[3])(this->data);
 }
};

template<typename T>
void (*const MyFunction::vtables[4])() =
{
 (void (*)())MyFunction::functorDestructor<T>,
 (void (*)())MyFunction::functorCopyCtor<T>,
 (void (*)())MyFunction::functorMoveCtor<T>,
 (void (*)())MyFunction::functorInvoke<T>,
};

#include <iostream>
#include <functional>
#include <new>

struct Point
{
 int x;
 int y;
};

std::ostream& operator<<(std::ostream& os, const Point& point)
{
 os << point.x << ", " << point.y;
 return os;
}

class Shape
{
private:
 template<typename T>
 class Adapter
 {
 public:
  Adapter(const T& shape)
   : shape(shape) { }
  void operator()() const
  {
   shape.draw();
  }
 private:
  T shape;
 };
public:
 template<typename T>
 Shape(const T& shape)
  : function(Adapter<T>(shape)) { }
 void draw() const
 {
  function();
 }
private:
 std::function<void()> function;
};

class Line
{
public:
 Line() { }
 Line(Point p0, Point p1)
  : endpoint{ p0, p1 } { }
 Line(const Line&) = default;
 Line& operator=(const Line&) = default;
 void draw() const
 {
  std::cout << "Drawing a line: " << endpoint[0] << "; " << endpoint[1]
   << std::endl;
 }
private:
 Point endpoint[2];
};

class Rectangle
{
public:
 Rectangle() { }
 Rectangle(Point v0, Point v1, bool filled)
  : vertex{ v0, v1 }, filled(filled) { }
 Rectangle(const Rectangle&) = default;
 Rectangle& operator=(const Rectangle&) = default;
 void draw() const
 {
  std::cout << "Drawing a rectangle: " << vertex[0] << "; " << vertex[1]
   << "; " << (filled ? "filled" : "blank") << std::endl;
 }
private:
 Point vertex[2];
 bool filled;
};

#include <iostream>
#include <new>
#include <type_traits>
#include <utility>

struct Point
{
 int x;
 int y;
 bool operator==(const Point& rhs) const
 {
  return this->x == rhs.x && this->y == rhs.y;
 }
};

std::ostream& operator<<(std::ostream& os, const Point& point)
{
 os << point.x << ", " << point.y;
 return os;
}

class Shape
{
protected:
 using FuncPtr = void (*)();
 using FuncPtrCopy = void (*)(Shape*, const Shape*);
 static constexpr std::size_t funcIndexCopy = 0;
 using FuncPtrDestruct = void (*)(Shape*);
 static constexpr std::size_t funcIndexDestruct = 1;
 using FuncPtrCompare = bool (*)(const Shape*, const Shape*);
 static constexpr std::size_t funcIndexCompare = 2;
 using FuncPtrDraw = void (*)(const Shape*);
 static constexpr std::size_t funcIndexDraw = 3;
 static constexpr std::size_t funcIndexTotal = 4;
 class ShapeData
 {
 public:
  static constexpr std::size_t size = 16;
  template<typename T>
  struct IsLocal : std::integral_constant<bool,
   (sizeof(T) <= size) && std::is_trivially_copyable<T>::value> { };
 private:
  char placeholder[size];
  template<typename T, typename U = void>
  using EnableIfLocal =
   typename std::enable_if<IsLocal<T>::value, U>::type;
  template<typename T, typename U = void>
  using EnableIfHeap =
   typename std::enable_if<!IsLocal<T>::value, U>::type;
 public:
  ShapeData() { }
  template<typename T, typename... Args>
  EnableIfLocal<T> construct(Args&& ... args)
  {
   new (reinterpret_cast<T*>(this)) T(std::forward<Args>(args)...);
  }
  template<typename T, typename... Args>
  EnableIfHeap<T> construct(Args&& ... args)
  {
   this->access<T*>() = new T(std::forward<Args>(args)...);
  }
  template<typename T>
  EnableIfLocal<T> destruct()
  {
   this->access<T>().~T();
  }
  template<typename T>
  EnableIfHeap<T> destruct()
  {
   delete this->access<T*>();
  }
  template<typename T>
  EnableIfLocal<T, T&> access()
  {
   return reinterpret_cast<T&>(*this);
  }
  template<typename T>
  EnableIfHeap<T, T&> access()
  {
   return *this->access<T*>();
  }
  template<typename T>
  const T& access() const
  {
   return const_cast<ShapeData*>(this)->access<T>();
  }
 };
 Shape(const FuncPtr* vtable)
  : vtable(vtable) { }
public:
 Shape() { }
 Shape(const Shape& other)
  : vtable(other.vtable)
 {
  if (vtable)
   reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])(this, &other);
 }
 Shape& operator=(const Shape& other)
 {
  if (this != &other)
  {
   if (vtable)
    reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])
    (this);
   vtable = other.vtable;
   if (vtable)
    reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])
    (this, &other);
  }
  return *this;
 }
 Shape(Shape&& other) noexcept
  : vtable(other.vtable), data(other.data)
 {
  other.vtable = nullptr;
 }
 Shape& operator=(Shape&& other) noexcept
 {
  swap(other);
  return *this;
 }
 ~Shape()
 {
  if (vtable)
   reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])(this);
 }
 void swap(Shape& other) noexcept
 {
  using std::swap;
  swap(this->vtable, other.vtable);
  swap(this->data, other.data);
 }
 bool operator==(const Shape& rhs) const
 {
  if (this->vtable == nullptr || this->vtable != rhs.vtable)
   return false;
  return reinterpret_cast<FuncPtrCompare>(vtable[funcIndexCompare])
   (this, &rhs);
 }
 bool operator!=(const Shape& rhs) const
 {
  return !(*this == rhs);
 }
 void draw() const
 {
  if (vtable)
   reinterpret_cast<FuncPtrDraw>(vtable[funcIndexDraw])(this);
 }
protected:
 const FuncPtr* vtable = nullptr;
 ShapeData data;
 template<typename T>
 static void defaultCopy(Shape* dst, const Shape* src)
 {
  dst->data.construct<T>(src->data.access<T>());
 }
 template<typename T>
 static void defaultDestruct(Shape* shape)
 {
  shape->data.destruct<T>();
 }
 template<typename T>
 static bool defaultCompare(const Shape* lhs, const Shape* rhs)
 {
  return lhs->data.access<T>() == rhs->data.access<T>();
 }
};

namespace std
{
 void swap(Shape& lhs, Shape& rhs) noexcept
 {
  lhs.swap(rhs);
 }
}

class Line : public Shape
{
private:
 struct LineData
 {
  Point endpoint[2];
  LineData() { }
  LineData(Point p0, Point p1)
   : endpoint{ p0, p1 } { }
  bool operator==(const LineData& rhs) const
  {
   return this->endpoint[0] == rhs.endpoint[0]
    && this->endpoint[1] == rhs.endpoint[1];
  }
  bool operator!=(const LineData& rhs) const
  {
   return !(*this == rhs);
  }
 };
 static_assert(ShapeData::IsLocal<LineData>::value, "");
public:
 Line()
  : Shape(lineVtable)
 {
  data.construct<LineData>();
 }
 Line(Point p0, Point p1)
  : Shape(lineVtable)
 {
  data.construct<LineData>(p0, p1);
 }
 Line(const Line&) = default;
 Line& operator=(const Line&) = default;
 Line(Line&&) = default;
 Line& operator=(Line&&) = default;
 ~Line() = default;
private:
 static const FuncPtr lineVtable[funcIndexTotal];
 static ShapeData& accessData(Shape* shape)
 {
  return static_cast<Line*>(shape)->data;
 }
 static const ShapeData& accessData(const Shape* shape)
 {
  return accessData(const_cast<Shape*>(shape));
 }
 static void lineDraw(const Shape* line)
 {
  auto& data = static_cast<const Line*>(line)->data.access<LineData>();
  std::cout << "Drawing a line: " << data.endpoint[0] << "; "
   << data.endpoint[1] << std::endl;
 }
};

const Shape::FuncPtr Line::lineVtable[] =
{
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Line::lineDraw),
};

class Rectangle : public Shape
{
private:
 struct RectangleData
 {
  Point vertex[2];
  bool filled;
  RectangleData() { }
  RectangleData(Point v0, Point v1, bool filled)
   : vertex{ v0, v1 }, filled(filled) { }
  bool operator==(const RectangleData& rhs) const
  {
   return this->vertex[0] == rhs.vertex[0]
    && this->vertex[1] == rhs.vertex[1]
    && this->filled == rhs.filled;
  }
  bool operator!=(const RectangleData& rhs) const
  {
   return !(*this == rhs);
  }
 };
 static_assert(!ShapeData::IsLocal<RectangleData>::value, "");
public:
 Rectangle()
  : Shape(rectangleVtable)
 {
  data.construct<RectangleData>();
 }
 Rectangle(Point v0, Point v1, bool filled)
  : Shape(rectangleVtable)
 {
  data.construct<RectangleData>(v0, v1, filled);
 }
 Rectangle(const Rectangle&) = default;
 Rectangle& operator=(const Rectangle&) = default;
 Rectangle(Rectangle&&) = default;
 Rectangle& operator=(Rectangle&&) = default;
 ~Rectangle() = default;
private:
 static const FuncPtr rectangleVtable[funcIndexTotal];
 static ShapeData& accessData(Shape* shape)
 {
  return static_cast<Rectangle*>(shape)->data;
 }
 static const ShapeData& accessData(const Shape* shape)
 {
  return accessData(const_cast<Shape*>(shape));
 }
 static void rectangleDraw(const Shape* rect)
 {
  auto& data = accessData(rect).access<RectangleData>();
  std::cout << "Drawing a rectangle: " << data.vertex[0] << "; "
   << data.vertex[1] << "; " << (data.filled ? "filled" : "blank")
   << std::endl;
 }
};

const Shape::FuncPtr Rectangle::rectangleVtable[] =
{
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<RectangleData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<RectangleData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<RectangleData>),
 reinterpret_cast<Shape::FuncPtr>(Rectangle::rectangleDraw),
};

template<typename T>
Shape test(const T& s0)
{
 s0.draw();
 T s1 = s0;
 s1.draw();
 T s2;
 s2 = s1;
 s2.draw();
 Shape s3 = s0;
 s3.draw();
 Shape s4;
 s4 = s0;
 s4.draw();
 Shape s5 = std::move(s0);
 s5.draw();
 Shape s6;
 s6 = std::move(s5);
 s6.draw();
 return s6;
}

int main()
{
 Line line({ 1, 2 }, { 3, 4 });
 auto l2 = test(line);
 Rectangle rect({ 5, 6 }, { 7, 8 }, true);
 auto r2 = test(rect);
 std::swap(l2, r2);
 l2.draw();
 r2.draw();
}

class ShapeData
{
public:
 static constexpr std::size_t size = 16;
 static_assert(size >= sizeof(void*), "");
 template<typename T>
 struct IsLocal : std::integral_constant<bool,
  (sizeof(T) <= size) && std::is_trivially_copyable<T>::value> { };
private:
 char placeholder[size];
 template<typename T, typename U = void>
 using EnableIfLocal =
  typename std::enable_if<IsLocal<T>::value, U>::type;
 template<typename T, typename U = void>
 using EnableIfHeap =
  typename std::enable_if<!IsLocal<T>::value, U>::type;
public:
 ShapeData() { }
 template<typename T, typename... Args>
 EnableIfLocal<T> construct(Args&& ... args)
 {
  new (reinterpret_cast<T*>(this)) T(std::forward<Args>(args)...);
 }
 template<typename T, typename... Args>
 EnableIfHeap<T> construct(Args&& ... args)
 {
  this->access<T*>() = new T(std::forward<Args>(args)...);
 }
 template<typename T>
 EnableIfLocal<T> destruct()
 {
  this->access<T>().~T();
 }
 template<typename T>
 EnableIfHeap<T> destruct()
 {
  delete this->access<T*>();
 }
 template<typename T>
 EnableIfLocal<T, T&> access()
 {
  return reinterpret_cast<T&>(*this);
 }
 template<typename T>
 EnableIfHeap<T, T&> access()
 {
  return *this->access<T*>();
 }
 template<typename T>
 const T& access() const
 {
  return const_cast<ShapeData*>(this)->access<T>();
 }
};

class Shape
{
protected:
 using FuncPtr = void (*)();
 using FuncPtrCopy = void (*)(Shape*, const Shape*);
 static constexpr std::size_t funcIndexCopy = 0;
 using FuncPtrDestruct = void (*)(Shape*);
 static constexpr std::size_t funcIndexDestruct = 1;
 using FuncPtrCompare = bool (*)(const Shape*, const Shape*);
 static constexpr std::size_t funcIndexCompare = 2;
 using FuncPtrDraw = void (*)(const Shape*);
 static constexpr std::size_t funcIndexDraw = 3;
 static constexpr std::size_t funcIndexTotal = 4;
 // ...
public:
 // ...
protected:
 const FuncPtr* vtable = nullptr;
 ShapeData data;
 template<typename T>
 static void defaultCopy(Shape* dst, const Shape* src)
 {
  dst->data.construct<T>(src->data.access<T>());
 }
 template<typename T>
 static void defaultDestruct(Shape* shape)
 {
  shape->data.destruct<T>();
 }
 template<typename T>
 static bool defaultCompare(const Shape* lhs, const Shape* rhs)
 {
  return lhs->data.access<T>() == rhs->data.access<T>();
 }
};

class Shape
{
protected:
 // ...
 Shape(const FuncPtr* vtable)
  : vtable(vtable) { }
public:
 Shape() { }
 Shape(const Shape& other)
  : vtable(other.vtable)
 {
  if (vtable)
   reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])(this, &other);
 }
 Shape& operator=(const Shape& other)
 {
  if (this != &other)
  {
   if (vtable)
    reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])
    (this);
   vtable = other.vtable;
   if (vtable)
    reinterpret_cast<FuncPtrCopy>(vtable[funcIndexCopy])
    (this, &other);
  }
  return *this;
 }
 Shape(Shape&& other) noexcept
  : vtable(other.vtable), data(other.data)
 {
  other.vtable = nullptr;
 }
 Shape& operator=(Shape&& other) noexcept
 {
  swap(other);
  return *this;
 }
 ~Shape()
 {
  if (vtable)
   reinterpret_cast<FuncPtrDestruct>(vtable[funcIndexDestruct])(this);
 }
 void swap(Shape& other) noexcept
 {
  using std::swap;
  swap(this->vtable, other.vtable);
  swap(this->data, other.data);
 }
 bool operator==(const Shape& rhs) const
 {
  if (this->vtable == nullptr || this->vtable != rhs.vtable)
   return false;
  return reinterpret_cast<FuncPtrCompare>(vtable[funcIndexCompare])
   (this, &rhs);
 }
 bool operator!=(const Shape& rhs) const
 {
  return !(*this == rhs);
 }
 void draw() const
 {
  if (vtable)
   reinterpret_cast<FuncPtrDraw>(vtable[funcIndexDraw])(this);
 }
protected:
 // ...
};

namespace std
{
 void swap(Shape& lhs, Shape& rhs) noexcept
 {
  lhs.swap(rhs);
 }
}

Shape& operator=(Shape other)
{
 swap(other);
 return *this;
}

class Line : public Shape
{
protected:
 static constexpr std::size_t funcIndexDebug = funcIndexTotal;
 using FuncPtrDebug = void (*)(const Line*);
 static constexpr std::size_t funcIndexTotalLine = funcIndexTotal + 1;
 struct LineData
 {
  Point endpoint[2];
  LineData() { }
  LineData(Point p0, Point p1)
   : endpoint{ p0, p1 } { }
  bool operator==(const LineData& rhs) const
  {
   return this->endpoint[0] == rhs.endpoint[0]
    && this->endpoint[1] == rhs.endpoint[1];
  }
  bool operator!=(const LineData& rhs) const
  {
   return !(*this == rhs);
  }
 };
 Line(const FuncPtr* vtable)
  : Shape(vtable) { }
public:
 Line()
  : Shape(lineVtable)
 {
  data.construct<LineData>();
 }
 Line(Point p0, Point p1)
  : Shape(lineVtable)
 {
  data.construct<LineData>(p0, p1);
 }
 Line(const Line&) = default;
 Line& operator=(const Line&) = default;
 Line(Line&&) = default;
 Line& operator=(Line&&) = default;
 ~Line() = default;
 void debug() const
 {
  if (vtable)
   reinterpret_cast<FuncPtrDebug>(vtable[funcIndexDebug])(this);
 }
private:
 static const FuncPtr lineVtable[funcIndexTotalLine];
 static ShapeData& accessData(Shape* shape)
 {
  return static_cast<Line*>(shape)->data;
 }
 static const ShapeData& accessData(const Shape* shape)
 {
  return accessData(const_cast<Shape*>(shape));
 }
 static void lineDraw(const Shape* line)
 {
  auto& data = static_cast<const Line*>(line)->data.access<LineData>();
  std::cout << "Drawing a line: " << data.endpoint[0] << "; "
   << data.endpoint[1] << std::endl;
 }
 static void lineDebug(const Line* line)
 {
  std::cout << "Line debug:\n\t";
  lineDraw(line);
 }
};

const Shape::FuncPtr Line::lineVtable[] =
{
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<LineData>),
 reinterpret_cast<Shape::FuncPtr>(Line::lineDraw),
 reinterpret_cast<Shape::FuncPtr>(Line::lineDebug),
};

class ThickLine : public Line
{
protected:
 struct ThickLineData
 {
  LineData lineData;
  int width;
  ThickLineData() { }
  ThickLineData(Point p0, Point p1, int width)
   : lineData{ p0, p1 }, width(width) { }
  ThickLineData(LineData data, int width)
   : lineData(data), width(width) { }
  bool operator==(const ThickLineData& rhs) const
  {
   return this->lineData == rhs.lineData
    && this->width == rhs.width;
  }
  bool operator!=(const ThickLineData& rhs) const
  {
   return !(*this == rhs);
  }
 };
public:
 ThickLine()
  : Line(thickLineVtable)
 {
  data.construct<ThickLineData>();
 }
 ThickLine(Point p0, Point p1, int width)
  : Line(thickLineVtable)
 {
  data.construct<ThickLineData>(p0, p1, width);
 }
 ThickLine(const ThickLine&) = default;
 ThickLine& operator=(const ThickLine&) = default;
 ThickLine(ThickLine&&) = default;
 ThickLine& operator=(ThickLine&&) = default;
 ~ThickLine() = default;
private:
 static const FuncPtr thickLineVtable[funcIndexTotalLine];
 static ShapeData& accessData(Shape* shape)
 {
  return static_cast<ThickLine*>(shape)->data;
 }
 static const ShapeData& accessData(const Shape* shape)
 {
  return accessData(const_cast<Shape*>(shape));
 }
 static void thickLineDraw(const Shape* line)
 {
  auto& data = static_cast<const ThickLine*>(line)->data.access<ThickLineData>();
  std::cout << "Drawing a thick line: " << data.lineData.endpoint[0] << "; "
   << data.lineData.endpoint[1] << "; " << data.width << std::endl;
 }
 static void thickLineDebug(const Line* line)
 {
  std::cout << "ThickLine debug:\n\t";
  thickLineDraw(line);
 }
};

const Shape::FuncPtr ThickLine::thickLineVtable[] =
{
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCopy<ThickLineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultDestruct<ThickLineData>),
 reinterpret_cast<Shape::FuncPtr>(Shape::defaultCompare<ThickLineData>),
 reinterpret_cast<Shape::FuncPtr>(ThickLine::thickLineDraw),
 reinterpret_cast<Shape::FuncPtr>(ThickLine::thickLineDebug),
};

class A { };
class B { };
class A1 : public A { B b; };
class B1 : public B { A a; };

class Shape
{
 VP_BASE(Shape, 16, 1);
 static constexpr std::size_t funcIndexDraw = 0;
public:
 void draw() const
 {
  if (vtable)
   VP_BASE_VFUNCTION(void(*)(const Shape*), funcIndexDraw)(this);
 }
};

VP_BASE_SWAP(Shape);

class Line : public Shape
{
 VP_DERIVED(Line);
private:
 struct LineData
 {
  Point endpoint[2];
  LineData() { }
  LineData(Point p0, Point p1)
   : endpoint{ p0, p1 } { }
  bool operator==(const LineData& rhs) const
  {
   return this->endpoint[0] == rhs.endpoint[0]
    && this->endpoint[1] == rhs.endpoint[1];
  }
  bool operator!=(const LineData& rhs) const
  {
   return !(*this == rhs);
  }
 };
public:
 Line()
  : VP_DERIVED_INITIALIZE(Shape, Line)
 {
  VP_DERIVED_CONSTRUCT(LineData);
 }
 Line(Point p0, Point p1)
  : VP_DERIVED_INITIALIZE(Shape, Line)
 {
  VP_DERIVED_CONSTRUCT(LineData, p0, p1);
 }
private:
 static void lineDraw(const Shape* line)
 {
  auto& data = VP_DERIVED_ACCESS(const Line, LineData, line);
  std::cout << "Drawing a line: " << data.endpoint[0] << "; "
   << data.endpoint[1] << std::endl;
 }
};

VP_DERIVED_VTABLE(Line, LineData,
 VP_DERIVED_VFUNCTION(Line, lineDraw),
);

class Rectangle : public Shape
{
 VP_DERIVED(Rectangle);
private:
 struct RectangleData
 {
  Point vertex[2];
  bool filled;
  RectangleData() { }
  RectangleData(Point v0, Point v1, bool filled)
   : vertex{ v0, v1 }, filled(filled) { }
  bool operator==(const RectangleData& rhs) const
  {
   return this->vertex[0] == rhs.vertex[0]
    && this->vertex[1] == rhs.vertex[1]
    && this->filled == rhs.filled;
  }
  bool operator!=(const RectangleData& rhs) const
  {
   return !(*this == rhs);
  }
 };
public:
 Rectangle()
  : VP_DERIVED_INITIALIZE(Shape, Rectangle)
 {
  VP_DERIVED_CONSTRUCT(RectangleData);
 }
 Rectangle(Point v0, Point v1, bool filled)
  : VP_DERIVED_INITIALIZE(Shape, Rectangle)
 {
  VP_DERIVED_CONSTRUCT(RectangleData, v0, v1, filled);
 }
private:
 static void rectangleDraw(const Shape* rect)
 {
  auto& data = VP_DERIVED_ACCESS(const Rectangle, RectangleData, rect);
  std::cout << "Drawing a rectangle: " << data.vertex[0] << "; "
   << data.vertex[1] << "; " << (data.filled ? "filled" : "blank")
   << std::endl;
 }
};

VP_DERIVED_VTABLE(Rectangle, RectangleData,
 VP_DERIVED_VFUNCTION(Rectangle, rectangleDraw),
);