Getting rid of dynamic polymorphism and classes

[Tommi]

Here's the duck-typing design pattern they introduce in the video
I posted (in C++ again, sorry):

#include <conio.h>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>

class SomeShape
{
public:
      SomeShape() = default;
      explicit SomeShape(int volume) {}

      void draw() const
      {
          _cprintf("Drawing SomeShape\n");
      }
};

class OtherShape
{
public:
      OtherShape() = default;
      explicit OtherShape(int x, int y) {}

      void draw() const
      {
          _cprintf("Drawing OtherShape\n");
      }
};

class ShapeInterface
{
public:
      virtual void draw() const = 0;

      virtual ~ShapeInterface() {}
};

template <typename T>
class PolymorphicShape : public ShapeInterface
{
public:
      template <typename ...Args>
      PolymorphicShape(Args&&... args)
          : _shape (std::forward<Args>(args)...)
      {}

      void draw() const override
      {
          _shape.draw();
      }

private:
      T _shape;
};

template <typename T, typename _ = void>
struct is_shape
      : std::false_type
{};

template <typename T>
struct is_shape<T, typename std::enable_if<
      std::is_same<decltype(T().draw()), void>::value
>::type>
      : std::true_type
{};

template <typename T>
auto drawAgain(const T& shape) -> typename std::enable_if<
      is_shape<T>::value
>::type
{
      shape.draw();
}

int main()
{
      std::vector<std::unique_ptr<ShapeInterface>> shapes;

      shapes.emplace_back(new PolymorphicShape<SomeShape>(42));
      shapes.emplace_back(new PolymorphicShape<OtherShape>(1, 2));

      // Dynamic polymorphism:
      shapes[0]->draw(); // Prints: Drawing SomeShape
      shapes[1]->draw(); // Prints: Drawing OtherShape

      // Static polymorphism:
      drawAgain(SomeShape(123));   // Prints: Drawing SomeShape
      drawAgain(OtherShape(2, 4)); // Prints: Drawing OtherShape

      _getch();
      return 0;
}