More C++ Idioms/Type Erasure
Type Erasure
edit
Intent
editTo provide a type-neutral container that interfaces a variety of concrete types.
Also Known As
edit"Variant"[citation needed] (not to be confused with std::variant
). This technique is used inside std::any
and std::function
.
Motivation
editIt is often useful to have a variable which can contain more than one type. Type Erasure is a technique to represent a variety of concrete types through a single generic interface.
Implementation and Example
editType Erasure is achieved in C++ by encapsulating a concrete implementation in a generic wrapper and providing virtual accessor methods to the concrete implementation via a generic interface.
The key components in this example interface are var, inner_base and inner classes:
struct var{
struct inner_base{
using ptr = std::unique_ptr<inner_base>;
};
template <typename _Ty> struct inner : inner_base{};
private:
typename inner_base::ptr _inner;
};
The var class holds a pointer to the inner_base class. Concrete implementations on inner (such as inner<int> or inner<std::string>) inherit from inner_base. The var representation will access the concrete implementations through the generic inner_base interface. To hold arbitrary types of data a little more scaffolding is needed:
struct var{
template <typename _Ty> var(_Ty src) : _inner(new inner<_Ty>(std::forward<_Ty>(src))) {} //construct an internal concrete type accessible through inner_base
struct inner_base{
using ptr = std::unique_ptr<inner_base>;
};
template <typename _Ty> struct inner : inner_base{
inner(_Ty newval) : _value(newval) {}
private:
_Ty _value;
};
private:
typename inner_base::ptr _inner;
};
The utility of an erased type is to assign multiple typed values to it so an assignment operator achieves just that:
struct var{
template <typename _Ty> var& operator = (_Ty src) {
_inner = std::make_unique<inner<_Ty>>(std::forward<_Ty>(src));
return *this;
}
struct inner_base{
using ptr = std::unique_ptr<inner_base>;
};
template <typename _Ty> struct inner : inner_base{
inner(_Ty newval) : _value(newval) {}
private:
_Ty _value;
};
private:
typename inner_base::ptr _inner;
};
Creating an erased type and assigning it various values isn't of much use unless you can interrogate it. One useful method is to query for the underlying type info:
struct var{
const std::type_info& Type() const { return _inner->Type(); }
struct inner_base{
using ptr = std::unique_ptr<inner_base>;
virtual const std::type_info& Type() const = 0;
};
template <typename _Ty> struct inner : inner_base{
virtual const std::type_info& Type() const override { return typeid(_Ty); }
};
private:
typename inner_base::ptr _inner;
};
Here the var class forwards calls of Type() to it's inner_base interface which is overridden by the concrete inner<_Ty> subclass which ultimately returns the underlying type. This technique of forwarding accessor methods to a virtual interface which is overridden by concrete implementations is expanded for a fully useful generic type.
Complete Implementation
editstruct var {
var() : _inner(new inner<int>(0)){} //default construct to an integer
var(const var& src) : _inner(src._inner->clone()) {} //copy constructor calls clone method of concrete type
template <typename _Ty> var(_Ty src) : _inner(new inner<_Ty>(std::forward<_Ty>(src))) {}
template <typename _Ty> var& operator = (_Ty src) { //assign to a concrete type
_inner = std::make_unique<inner<_Ty>>(std::forward<_Ty>(src));
return *this;
}
var& operator=(const var& src) { //assign to another var type
var oTmp(src);
std::swap(oTmp._inner, this->_inner);
return *this;
}
//interrogate the underlying type through the inner_base interface
const std::type_info& Type() const { return _inner->Type(); }
bool IsPOD() const { return _inner->IsPOD(); }
size_t Size() const { return _inner->Size(); }
//cast the underlying type at run-time
template <typename _Ty> _Ty& cast() {
return *dynamic_cast<inner<_Ty>&>(*_inner);
}
template <typename _Ty> const _Ty& cast() const {
return *dynamic_cast<inner<_Ty>&>(*_inner);
}
struct inner_base {
using Pointer = std::unique_ptr < inner_base > ;
virtual ~inner_base() {}
virtual inner_base * clone() const = 0;
virtual const std::type_info& Type() const = 0;
virtual bool IsPOD() const = 0;
virtual size_t Size() const = 0;
};
template <typename _Ty> struct inner : inner_base {
inner(_Ty newval) : _value(std::move(newval)) {}
virtual inner_base * clone() const override { return new inner(_value); }
virtual const std::type_info& Type() const override { return typeid(_Ty); }
_Ty & operator * () { return _value; }
const _Ty & operator * () const { return _value; }
virtual bool IsPOD() const { return std::is_pod<_Ty>::value; }
virtual size_t Size() const { return sizeof(_Ty); }
private:
_Ty _value;
};
inner_base::Pointer _inner;
};
//this is a specialization of an erased std::wstring
template <>
struct var::inner<std::wstring> : var::inner_base{
inner(std::wstring newval) : _value(std::move(newval)) {}
virtual inner_base * clone() const override { return new inner(_value); }
virtual const std::type_info& Type() const override { return typeid(std::wstring); }
std::wstring & operator * () { return _value; }
const std::wstring & operator * () const { return _value; }
virtual bool IsPOD() const { return false; }
virtual size_t Size() const { return _value.size(); }
private:
std::wstring _value;
};
Example Implementation from Sean Parent talk
edittemplate<typename T>
void draw(const T& x, std::ostream& out, size_t position) {
out << std::string(position, ' ') << x << std::endl;
}
class object_t {
public:
template<typename T>
object_t(T x) : self_(std::make_shared<model<T>>(std::move(x))) {}
friend void draw(const object_t& x, std::ostream& out, size_t position) {
x.self_->draw_(out, position);
}
private:
struct concept_t {
virtual ~concept_t() = default;
virtual void draw_(std::ostream&, size_t) const = 0;
};
template<typename T>
struct model final : concept_t {
model(T x) : data_(std::move(x)) {}
void draw_(std::ostream& out, size_t position) const override {
draw(data_, out, position);
}
T data_;
};
std::shared_ptr<const concept_t>self_;
};