C ++ Тип схема стирания. Как обнаружить скрытый тип времени компиляции ⇐ C++

[Anonymous]

Я посещал программное обеспечение C ++ Course, и я подумал, что книга разработки программного обеспечения C ++ написана Клаусом Иглбергером. В их материале есть очень хороший пример стирания типа с использованием ручной отправки. < /P>
#include
#include
#include
#include
#include
#include
class Circle
{
public:
explicit Circle( double radius )
: radius_( radius )
{}
auto operator(const Circle&) const = default;
double radius() const { return radius_; }

private:
double radius_;
};

class Square
{
public:

auto operator(const Square&) const = default;
explicit Square( double side )
: side_( side )
{}

double side() const { return side_; }

private:
double side_;

};

class Shape
{
public:
template< typename ShapeT
, typename DrawStrategy >
Shape( ShapeT shape, DrawStrategy drawer )
: pimpl_(
new OwningModel( std::move(shape)
, std::move(drawer) )
, []( void* shapeBytes ){
using Model = OwningModel;
auto* const model = static_cast(shapeBytes);
delete model;
} )
, draw_(
[]( void* shapeBytes ){
using Model = OwningModel;
auto* const model = static_cast(shapeBytes);
(model->drawer_)( model->shape_ );
} )
, clone_(
[]( void* shapeBytes ) -> void* {
using Model = OwningModel;
auto* const model = static_cast(shapeBytes);
return new Model( *model );
} )

,type_id_( &typeid(ShapeT) )
{
}

Shape( Shape const& other )
: pimpl_( other.clone_( other.pimpl_.get() ), other.pimpl_.get_deleter() )
, draw_ ( other.draw_ )
, clone_( other.clone_ )
{}

Shape& operator=( Shape const& other )
{

// Only allow assignment if types are the same
// Copy-and-Swap Idiom
using std::swap;
Shape copy( other );

swap( pimpl_, copy.pimpl_ );
swap( draw_, copy.draw_ );
swap( clone_, copy.clone_ );

return *this;
}

~Shape() = default;
Shape( Shape&& ) = default;
Shape& operator=( Shape&& ) = default;

private:
friend void draw( Shape const& shape )
{
shape.draw_( shape.pimpl_.get() );
}

template< typename ShapeT
, typename DrawStrategy >
struct OwningModel
{
OwningModel( ShapeT value, DrawStrategy drawer )
: shape_( std::move(value) )
, drawer_( std::move(drawer) )
{}

ShapeT shape_;
DrawStrategy drawer_;
};

using DestroyOperation = void(void*);
using DrawOperation = void(void*);
using CloneOperation = void*(void*);

const std::type_info* type_id_ { nullptr };
std::unique_ptr pimpl_;
DrawOperation* draw_ { nullptr };
CloneOperation* clone_{ nullptr };
friend class ShapeConstRef;
template< typename ShapeU
, typename DrawStrategyU >
friend class NonOwningShapeModel;
};

int main()
{
// Create a circle as one representative of a concrete shape type
Circle circle{ 3.14 };
Square square{4};
// Create a drawing strategy in form of a lambda

auto drawer = []( auto c ){std::cout
Копирование квадрата в круг успешно скомпилируется, что меня удивляет. Это логическая ошибка. Я пытаюсь найти способ обнаружить во времени компиляции реального типа формы и избегать вызова оператора = назначение.

Подробнее здесь: https://stackoverflow.com/questions/796 ... mpile-time