Какие методы стирания типа есть и как они работают? ⇐ C++

[Anonymous]

(с стиранием типа, я имею в виду скрыть некоторую или всю информацию о типах, касающейся класса, что -то вроде Boost.any.) Моя надежда на то, чтобы найти какую -то сумасшедшую технику, о которой кто -то думал в его/ее мрачном часе. < /p>

Первый и наиболее очевидный, и обычно используется подход, который, как я знаю, являются виртуальными функциями. Просто скрыть реализацию вашего класса в иерархии класса на основе интерфейса. Многие библиотеки Boost делают это, например, Boost.ny, чтобы скрыть ваш тип и Boost.shared_ptr делает это, чтобы скрыть механик распределения (DE). < /p>

Тогда есть опция с указателями функций на шаблонные функции, при этом удерживая фактический объект в void*< /code> указатель, например, Boost.function, чтобы скрыть реальный тип функтора. Примеры реализаций можно найти в конце вопроса. Пожалуйста, предоставьте им, если возможно, с примером кода, варианты использования, ваш опыт работы с ними и, возможно, ссылки для дальнейшего чтения. < /P>

Редактировать < /strong>

(поскольку я не был уверен, если я не уверен, что можно добавить в качестве ответа, или просто редактировать вопрос, я просто не могу (Br />

needicique, чтобы скрыть на самом деле. Функции или void*< /code> Fiddling - это тот, который использует здесь один Gman, с актуальностью к моему вопросу о том, как именно это работает.#include
#include

// NOTE: The class name indicates the underlying type erasure technique

// this behaves like the Boost.Any type w.r.t. implementation details
class Any_Virtual{
struct holder_base{
virtual ~holder_base(){}
virtual holder_base* clone() const = 0;
};

template
struct holder : holder_base{
holder()
: held_()
{}

holder(T const& t)
: held_(t)
{}

virtual ~holder(){
}

virtual holder_base* clone() const {
return new holder(*this);
}

T held_;
};

public:
Any_Virtual()
: storage_(0)
{}

Any_Virtual(Any_Virtual const& other)
: storage_(other.storage_->clone())
{}

template
Any_Virtual(T const& t)
: storage_(new holder(t))
{}

~Any_Virtual(){
Clear();
}

Any_Virtual& operator=(Any_Virtual const& other){
Clear();
storage_ = other.storage_->clone();
return *this;
}

template
Any_Virtual& operator=(T const& t){
Clear();
storage_ = new holder(t);
return *this;
}

void Clear(){
if(storage_)
delete storage_;
}

template
T& As(){
return static_cast(storage_)->held_;
}

private:
holder_base* storage_;
};

// the following demonstrates the use of void pointers
// and function pointers to templated operate functions
// to safely hide the type

enum Operation{
CopyTag,
DeleteTag
};

template
void Operate(void*const& in, void*& out, Operation op){
switch(op){
case CopyTag:
out = new T(*static_cast(in));
return;
case DeleteTag:
delete static_cast(out);
}
}

class Any_VoidPtr{
public:
Any_VoidPtr()
: object_(0)
, operate_(0)
{}

Any_VoidPtr(Any_VoidPtr const& other)
: object_(0)
, operate_(other.operate_)
{
if(other.object_)
operate_(other.object_, object_, CopyTag);
}

template
Any_VoidPtr(T const& t)
: object_(new T(t))
, operate_(&Operate)
{}

~Any_VoidPtr(){
Clear();
}

Any_VoidPtr& operator=(Any_VoidPtr const& other){
Clear();
operate_ = other.operate_;
operate_(other.object_, object_, CopyTag);
return *this;
}

template
Any_VoidPtr& operator=(T const& t){
Clear();
object_ = new T(t);
operate_ = &Operate;
return *this;
}

void Clear(){
if(object_)
operate_(0,object_,DeleteTag);
object_ = 0;
}

template
T& As(){
return *static_cast(object_);
}

private:
typedef void (*OperateFunc)(void*const&,void*&,Operation);

void* object_;
OperateFunc operate_;
};

int main(){
Any_Virtual a = 6;
std::cout

Подробнее здесь: https://stackoverflow.com/questions/545 ... -they-work