Учебный пример ООП

#include <iostream>
#include <memory>
#include <assert.h>
#include <string>
#include <tuple>
 
//https://www.cyberforum.ru/oop/thread1806816.html
 
#define DRAW_FUNC(_obj, _text,_func) std::cout << (void*)&(_obj) << ":" << (_text) << "::" << (_func) << std::endl
 
namespace universal {
    class Config
    {
    public:
        typedef double Value;
    };
 
    class Point {
    public:
        Config::Value coordX; // Атрибут - координата X
        Config::Value coordY; // Атрибут - координата Y
 
        Point() :coordX(0.), coordY(0.) {}
        Point(Config::Value _coordX, Config::Value _coordY) :
            coordX(_coordX),
            coordY(_coordY)
        {}
 
        Point(const Point& _c) = default;
        Point(Point&& _c) = default;
        Point& operator=(const Point& _c) = default;
        Point& operator=(Point&& _c) = default;
    };
 
    class Point3D :public Point {
    public:
        Config::Value coordZ; // Атрибут - координата Z
 
        Point3D() :coordZ(0.) {}
        Point3D(Config::Value _coordX, Config::Value _coordY, Config::Value _coordZ) :
            Point(_coordX, _coordY),
            coordZ(_coordZ)
        {}
 
        Point3D(const Point& _c) {
            Point::operator=(_c);
            coordZ = 0.;
        }
 
        Point3D(const Point3D& _c) = default;
        Point3D(Point3D&& _c) = default;
        Point3D& operator=(const Point3D& _c) = default;
        Point3D& operator=(Point3D&& _c) = default;
    };
 
    class Object {
    public:
        virtual ~Object() {}
    };
}
 
namespace models
{
    template<typename Config, typename FaceShape>
    class Shape : public Config::template ShapeParent<FaceShape>
    {
    public:
        typename Config::Point& getCoord() { return coord; }
        const typename Config::Point& getCoord()const { return coord; }
 
        typename Config::ShapeType getShapeType()const { return type; }
 
    protected:
        // Защищенная часть класса, доступная только
        // выведенным из него классам
        template<typename FaceShape>
        Shape(typename Config::ShapeType /*_type*/, FaceShape& _face) :
            Config::template ShapeParent<FaceShape>(_face)
        {
        }
 
        typename Config::Point      coord;  // Атрибут - координаты
    };
 
    // Класс Круг выведенный из класса Фигура
    template<typename Config>
    class Circle : public Config::template BaseShape<Config, Circle<Config>>
    {
    public:
        typename Config::Value getRadius()const { return radius; }
        void setRadius(typename Config::Value _radius) { radius = _radius; }
 
        Circle():
            Config::template BaseShape<Config, Circle<Config>>(typename Config::ShapeType::Circle, *this)
        {}
    private:
        // Внутренняя часть доступная только самому классу
        typename Config::Value radius; // Атрибут - длина радиуса
    };
 
    // Класс Квадрат выведенный из класса Фигура
    template<typename Config>
    class Square : public Config::template BaseShape<Config, Square<Config>>
    {
    public:
        typename Config::Value getSide()const { return side; }
        void setSide(typename Config::Value _side) { side = _side; }
 
        Square():
            Config::template BaseShape<Config, Square<Config>>(typename Config::ShapeType::Square, *this)
        {}
    private:
        // Внутренняя часть доступная только самому классу
        typename Config::Value side; // Атрибут - длина стороны квадрата
    };
 
    class Config2D
    {
    public:
        typedef universal::Config::Value Value;
        typedef universal::Point Point;
        typedef universal::Object Object;
 
        template<typename FaceShape>
        using ShapeParent = universal::Object;
 
        template<typename Config, typename FaceShape>
        using BaseShape = models::Shape<Config, FaceShape>;
 
        enum class ShapeType {
            Circle,
            Square
        };
    };
}
 
namespace views_static
{
    template<typename FaceShape>
    class ShapeDrawAspect {
    protected:
        FaceShape& face;
    
    protected:
        ShapeDrawAspect(FaceShape& _face):face(_face){}
 
        ShapeDrawAspect& operator=(const ShapeDrawAspect& _c) {}
 
    public:
        template<typename Renderer>
        void draw(Renderer& _renderer)
        {
            DRAW_FUNC(*this, "ShapeDrawAspect", std::string("draw(") + typeid(_renderer).name() + "&)");
            _renderer.render(face);
        } // Перерисовать фигуру
    };
 
    template<typename FaceShape>
    class ShapeAllAspects: public ShapeDrawAspect<FaceShape> {
    protected:
        ShapeAllAspects(FaceShape& _shape):
            ShapeDrawAspect<FaceShape>(_shape)
        {
        }
 
        ShapeAllAspects& operator=(const ShapeAllAspects& _c) = default;
    };
    
 
    class Config2D_Static:public models::Config2D
    {
    public:
        template<typename FaceShape>
        using ShapeParent = ShapeAllAspects<FaceShape>;
    };
 
    typedef models::Circle<Config2D_Static> Circle;
    typedef models::Square<Config2D_Static> Square;
}
 
namespace renderers_static {
 
    template<typename Shape, typename Renderer>
    class Converter {
    public:
        void render(Shape& _shape, Renderer& _renderer)
        {
            typename Renderer::Data data;
            //заполняем data
            _renderer.render(data);
        }
    };
    template<typename Renderer>
    class Converter<views_static::Circle, Renderer> {
    public:
        static void render(views_static::Circle& _shape, Renderer& _renderer)
        {
            DRAW_FUNC(_shape, "Converter<models::Circle, Renderer>",
                std::string("render(models::Circle&, ") + typeid(_renderer).name() + "&)");
 
            typename Renderer::Data data;
            //заполняем data
            _renderer.render(data);
        }
    };
    template<typename Renderer>
    class Converter<views_static::Square, Renderer> {
    public:
        static void render(views_static::Square& _shape, Renderer& _renderer)
        {
            DRAW_FUNC(_shape, "Converter<models::Square, Renderer>",
                std::string("render(models::Square&, ") + typeid(_renderer).name() + "&)");
 
            typename Renderer::Data data;
            //заполняем data
            _renderer.render(data);
        }
    };
 
 
    template<typename ActualRenderer>
    class UniversalRendererEngine {
    public:
        template<typename Shape>
        void render(Shape& _shape)
        {
            Converter<Shape, ActualRenderer>::render(_shape, static_cast<ActualRenderer&>(*this));
        }
    };
 
    class OpenGLRendererEngine :public UniversalRendererEngine<OpenGLRendererEngine> {
    public:
        using UniversalRendererEngine<OpenGLRendererEngine>::render;
        class Data {
        public:
        };
        void render(Data&)
        {
            DRAW_FUNC(*this, "OpenGLRenderEngine", "render(const Data&)");
            std::cout << std::endl;
        }
    };
    class DirectXRendererEngine :public UniversalRendererEngine<DirectXRendererEngine> {
    public:
        using UniversalRendererEngine<DirectXRendererEngine>::render;
        class Data {
        public:
        };
        void render(Data&)
        {
            DRAW_FUNC(*this, "DirectXRenderEngine", "render(const Data&)");
            std::cout << std::endl;
        }
    };
}
 
namespace views_dynamic
{
    template<typename Config>
    class ShapeTypeDrawer {
    protected:
        typename Config::ShapeType type;
 
    protected:
        ShapeTypeDrawer(typename Config::ShapeType _type):type(_type){}
    
    public:
        typename Config::ShapeType getType()const
        {
            return type;
        };
 
        template<typename Renderer>
        void draw(Renderer& _renderer)
        {
            DRAW_FUNC(*this, "ShapeBase", "draw(Renderer&)");
            _renderer.render(*this);
        } // Перерисовать фигуру
    };
    template<typename Config, typename FaceShape>
    class ShapeBase : public models::Shape<Config, FaceShape>, public ShapeTypeDrawer<Config>
    {
    protected:
        // Защищенная часть класса, доступная только
        // выведенным из него классам
        template<typename FaceShape>
        ShapeBase(typename Config::ShapeType _type, FaceShape& _face) :
            models::Shape<Config, FaceShape>(_type, _face),
            ShapeTypeDrawer<Config>(_type)
        {
        }
    };
 
    class Config2D_Dynamic :public models::Config2D
    {
    public:
        template<typename Config, typename FaceShape>
        using BaseShape = ShapeBase<Config, FaceShape>;
 
        typedef ShapeTypeDrawer<Config2D_Dynamic> Shape;
        typedef models::Circle<Config2D_Dynamic> Circle;
        typedef models::Square<Config2D_Dynamic> Square;
    };
 
    
}
 
namespace renderers_dynamic
{
    typedef views_dynamic::Config2D_Dynamic Config2D;
 
    class IRenderer {
    public:
        virtual void render(Config2D::Shape& _shape) = 0;
    };
 
    class OpenGLRenderer : public IRenderer
    {
    public:
        virtual void render(Config2D::Shape& _shape) override
        {
            DRAW_FUNC(_shape, "OpenGLRenderer", "render(Shape& _shape)");
            switch (_shape.getType())
            {
            case Config2D::ShapeType::Circle:
                render(static_cast<Config2D::Circle&>(_shape));
                break;
            case Config2D::ShapeType::Square:
                render(static_cast<Config2D::Square&>(_shape));
                break;
            default:
                assert(false);
                break;
            }
        }
 
    protected:
        void render(Config2D::Circle& _shape)
        {
            DRAW_FUNC(_shape, "OpenGLRenderer", "render(Circle& _shape)");
            std::cout << std::endl;
        }
        void render(Config2D::Square& _shape)
        {
            DRAW_FUNC(_shape, "OpenGLRenderer", "render(Square& _shape)");
            std::cout << std::endl;
        }
    };
 
    class DirectXRenderer : public IRenderer
    {
    public:
        virtual void render(Config2D::Shape& _shape) override
        {
            DRAW_FUNC(_shape, "DirectXRenderer", "render(Shape& _shape)");
            switch (_shape.getType())
            {
            case Config2D::ShapeType::Circle:
                render(static_cast<Config2D::Circle&>(_shape));
                break;
            case Config2D::ShapeType::Square:
                render(static_cast<Config2D::Square&>(_shape));
                break;
            default:
                assert(false);
                break;
            }
        }
 
    protected:
        void render(Config2D::Circle& _shape)
        {
            DRAW_FUNC(_shape, "DirectXRenderer", "render(Circle& _shape)");
            std::cout << std::endl;
        }
        void render(Config2D::Square& _shape)
        {
            DRAW_FUNC(_shape, "DirectXRenderer", "render(Square& _shape)");
            std::cout << std::endl;
        }
    };
}
 
 
namespace
{
    template<typename Func, std::size_t I = 0, typename... Tp>
    inline typename std::enable_if<I == sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...>& /*t*/, const Func& /*_f*/)
    { }
 
    template<typename Func, std::size_t I = 0, typename... Tp>
    inline typename std::enable_if<I < sizeof...(Tp), void>::type
        for_each(std::tuple<Tp...>& t, const Func& _f)
    {
        _f(std::get<I>(t));
        for_each<Func, I + 1, Tp...>(t, _f);
    }
 
}
 
int main()
{
    {
        std::cout << "=================== STATIC POLIMORFISM ===================" << std::endl;
        views_static::Circle circle;
        views_static::Square square;
 
        renderers_static::OpenGLRendererEngine openGLRenderer;
        renderers_static::DirectXRendererEngine directXRenderer;
 
        circle.draw(openGLRenderer);
        square.draw(openGLRenderer);
        
        circle.draw(directXRenderer);
        square.draw(directXRenderer);
    }
 
    {
        std::cout << "=================== STATIC POLIMORFISM with tuples ===================" << std::endl;
        auto shapes = std::make_tuple(
            views_static::Circle(),
            views_static::Square()
        );
        auto renderers = std::make_tuple(
            renderers_static::OpenGLRendererEngine(),
            renderers_static::DirectXRendererEngine()
        );
 
        for_each(renderers, [&shapes](auto& _renderer) {
            for_each(shapes, [&_renderer](auto& _shape) {
                _shape.draw(_renderer);
            });
        });
 
    }
 
    {
        std::cout << "=================== RUNTIME POLIMORFISM ===================" << std::endl;
 
        std::shared_ptr<renderers_dynamic::IRenderer> renderers[] = {
            std::make_shared<renderers_dynamic::OpenGLRenderer>(),
            std::make_shared<renderers_dynamic::DirectXRenderer>()
        };
        std::shared_ptr<views_dynamic::Config2D_Dynamic::Shape> shapes[] = {
            std::make_shared<views_dynamic::Config2D_Dynamic::Circle>(),
            std::make_shared<views_dynamic::Config2D_Dynamic::Square>()
        };
 
        for (auto& rend : renderers)
        {
            for (auto& sh : shapes)
            {
                sh->draw(*rend);
            }
        }
    }
    
    return 0;
}