Удалить void * в C ++ 11, используя стирание типа

Вот случайная идея. Мне все еще не нравится это все же. Вся идея этого дизайна плохая.

template <typename T>
struct Holder
{
public:
Holder(T const& v)
{
new (&m_v) T(v);
}

T const& get() const
{
return reinterpret_cast<T const&>(m_v);
}

T& get()
{
return reinterpret_cast<T&>(m_v);
}

~Holder()
{
std::cout << "~Holder() " << std::endl;
get().~T();
}

private:
char m_v[sizeof(T)];
};

Этот класс больше не делает так, как ваш, т.е. он не может хранить произвольные типы в std::vector<Holder> но только одного типа (std::vector<Holder<Foo>>). Комментарий был слишком маленьким, чтобы содержать этот код, и я хотел показать лучший синтаксис того, с чем вы играете;).

При этом единственный способ сделать то, что вы пытаетесь сделать, — это добавить второй слой для подсчета ссылок. То есть ты заменишь свой void* _v с чем-то, что напоминает shared_ptr но который не вызывает удаление, когда счетчик достигает нуля, а вызывает удаление (что, следовательно, должно храниться в этом новом классе). Фактически ваш класс выглядит в основном как этот новый класс, за исключением того, что вы должны сделать его не подлежащим копированию и обеспечить подсчет ссылок (т.е. через boost::intrusive_ptr). затем Holder может быть оберткой вокруг того, что можно копировать.

Вероятно, эта строка кода: delete reinterpret_cast<T*>(_v); не делает то, что я ожидаю …

Не совсем. Ваши типы, вероятно, используют копию ctor по умолчанию; это копирует ваш указатель данных _vи ваш удалитель. Поэтому, когда оба объекта разрушаются, оба средства удаления срабатывают, в результате чего данные удаляются дважды. (Примечание: вы не должны называть переменные, начинающиеся с _; такие идентификаторы зарезервированы для реализаций).

Вот что нужно для правильного стирания типа, при условии, что в нем нет ошибок. Лучшим способом было бы придерживаться boost :: any.

#include <utility>
struct EmptyType {}; // Thrown if unexpectedly empty
struct InvalidType {}; // Thrown if Holder(T) but get<U>.
struct Holder
{
Holder()
: data_()
, deleter_(e_deleter)
, copier_(e_copier)
, typetag_()
{
}
template<typename T>
Holder(const T& t)
: data_(erase_cast(new T))
, deleter_(deleter<T>)
// Need to explicitly carry T's copy behavior
// because Holder's default copy ctor isn't going to
, copier_(copier<T>)
// You need some way to protect against getting
// an Orange out of a Holder that holds an Apple.
, typetag_(id<T>())
{
}
Holder(const Holder& rhs)
: data_(rhs.copy())
, deleter_(rhs.deleter_)
, copier_(rhs.copier_)
, typetag_(rhs.typetag_)
{
}
template<typename T>
T get()
{
if (!data_) throw EmptyType();
T rv(fetch<T>());
return rv;
}
Holder(Holder&& rhs)
: data_()
, copier_(rhs.copier_)
, deleter_(rhs.deleter_)
, typetag_(rhs.typetag_)
{
std::swap(data_, rhs.data_);
}
~Holder()
{
destroy();
}
private:
// Reinterpret_cast wrappers labeled semantically
template<typename T>
static void* erase_cast(T* t) { return reinterpret_cast<void*>(t); }
template<typename T>
static T* unerase_cast(void* t) { return reinterpret_cast<T*>(t); }
// Return a data copy
void* copy() const { return copier_(data_); }
// Return const reference to data
template<typename T>
const T& fetch() {
if (typetag_!=id<T>()) throw InvalidType();
return *unerase_cast<T>(data_);
}
// Destroy data
void destroy() { deleter_(data_); data_=0; }

// ==== Type erased copy semantics ===
void*(*copier_)(void*);
template<typename T>
static void* copier(void* v) {
return erase_cast<T>(new T(*unerase_cast<T>(v)));
}
static void* e_copier(void*) { return 0; }

// ==== Type erased delete semantics ===
void(*deleter_)(void*);
template<typename T>
static void deleter(void* v) {
delete unerase_cast<T>(v);
}
static void e_deleter(void*) {}

// ==== Type protection using tagging (could also use typeid)
static int makenewid() { static int i=0; return i++;}
template<typename T>
static int id() { static int i=makenewid(); return i; }
// Type erased data
void* data_;
// Type erased tag
int typetag_;
};

…и вот некоторый тестовый / демонстрационный код:

#include <iostream>
#include <vector>
#define FAIL() std::cout << "Fail" << std::endl; return 1
int foos=0;
struct Foo { Foo(){++foos;} Foo(const Foo&){++foos;} ~Foo(){--foos;} };
int bars=0;
struct Bar { Bar(){++bars;} Bar(const Bar&){++bars;} ~Bar(){--bars;} };

int main() {
{
std::vector<Holder> v;
Foo fx,fy,fz; Bar ba,bb;
v.push_back(fx); v.push_back(fy); v.push_back(fz);
v.push_back(ba); v.push_back(ba); v.push_back(bb);
v.push_back(Holder());
try {
Foo y = v[2].get<Foo>();
}
catch (EmptyType&) { FAIL(); }
catch (InvalidType&) { FAIL(); }
try {
Foo y = v[4].get<Foo>();
FAIL();
}
catch (EmptyType&) { FAIL(); }
catch (InvalidType&) { }
try {
Foo y = v[6].get<Foo>();
FAIL();
}
catch (EmptyType&) {  }
catch (InvalidType&) { FAIL(); }
}
if (foos||bars) { FAIL(); }
std::cout << "Pass" << std::endl;
}

Результаты теста:

$ ./a.exe
Pass