crtp, C++ (vc++) - rextester

Language: Layout:

//Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x64

#include <iostream>
#include <memory>
#include <type_traits>
#include <vector>
#include <typeinfo>

struct abstract_base ; // base class for all data objects
struct base_manip // base class for all manips (pure interface)
                  // (a common non-templated base class with a virtual destructor)
{
    virtual ~base_manip() = default ;
    virtual void do_it( abstract_base& ab ) = 0 ;
    using pointer = std::unique_ptr<base_manip> ;
};

struct abstract_base // base class for all data objects (pure interface)
{
    virtual ~abstract_base() = default ;
    virtual base_manip::pointer manip() const = 0 ;
};

// CRTP implementation for derived class data objects
template < typename DERIVED > struct base : abstract_base
{

virtual base_manip::pointer manip() const override
    {
        // instantiate (defalt initialise) a manip of type DERIVED::manip
        static_assert( std::is_default_constructible<typename DERIVED::manip>::value, "not default constructible" ) ;
        return std::make_unique< typename DERIVED::manip >() ;
    }
};

struct derived : base<derived>
{
    // each derived class defines its own manipulator
    struct manip : base_manip
    {
        void do_it( abstract_base& b )
        {
            std::cout << "derived::manip::do_it\n" ;

// throw if do_it is called with an object of an incompatible type
            derived& d = dynamic_cast<derived&>(b) ;

// do something on d
            d.str += '!' ;
        }
    };

std::string str = "derived" ;
};

struct another_derived : base<another_derived>
{
    // each derived class defines its own manipulator
    struct manip :base_manip
    {
        void do_it( abstract_base& b )
        {
            std::cout << "another_derived::manip::do_it\n" ;
            another_derived& a = dynamic_cast<another_derived&>(b) ;
            // do something on a
            ++a.i ;
        }
    };

int i = 20 ;
};

void do_it( const std::vector<abstract_base*>& objects )
{
    for( auto& ptr : objects ) if(ptr)
    {
        #ifndef NDEBUG
            std::cout << "type " << typeid(*ptr).name() << " : " ;
        #endif // NDEBUG
        auto manip = ptr->manip() ;
        if(manip) manip->do_it(*ptr) ;
    }
}

int main()
{
    derived a, b, c ;
    another_derived d, e, f ;

// derived class does not define its own manip
    // objects of this class use the base class manip (another_derived::manip)
    struct more_derived : another_derived {} g, h, i;

do_it( { &a, &d, &g, &b, &e, &h, &c, &f, &i } ) ;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 5,41 sec, absolute running time: 0,44 sec, absolute service time: 5,88 sec