强制转换为 void* 并返回后如何删除指针

Question

As part of a "message"-class I try to transfer pointers of different types by casting them to void*-pointers and saving them in a wrapper class ("MsgData") that remembers the original type of the pointer.

For example a bool pointer:

bool* data = new bool;
event.wheel.y < 0 ? *data = false : *data = true;
send("all", this, MSG_MOUSE_SCROLL, MsgData(data));

The compatible Constructor of MsgData is called and the variable is saved as a member of my message class:

MsgData():                        type_(NULLPTR),    data_(nullptr)     {}  // Null
MsgData(const bool* data):        type_(BOOL),       data_((void*)data) {}  // Bool
MsgData(const std::string* data): type_(STRING_STD), data_((void*)data) {}  // std::string
// ... etc.

I can cast the pointers back and use them without any errors but when I try to delete them the program crashes:

~MsgData() {
    switch (type_) {
    case (BOOL):
        if ((bool*)data_)
            delete (bool*)data_;
        break;
    // ... etc.
    }
}

The bool pointer is just an example and the same happens with all other types and classes too. The program crashes only when I try to delete the pointer. Casting them back to their original type and using them is not a problem.

I researched the problem and found similar question like this one on StackOverflow but while it seems to be considered bad style to cast a pointer to void* and back I cannot find the reason why the program crashes.

Answer 1

Well, a better solution to the problem is to use boost::variant (or std::variant ). Once you start using that, all the headache of deleting and managing type and data will go automatically. You're not the first to face of a problem of this kind; many others have faced it, and the solution is available in the form of boost::variant or std::variant .

Anyway, since you're developing a solution yourself, here is my advise: construct an appropriate deleter in the constructor itself .. or whenever you know what type of data your class is going to hold:

MsgData()
 : type_(NULLPTR), data_(nullptr)     {} 

MsgData(const bool* data)
 : type_(BOOL), data_((void*)data), deleter_(&deleter<BOOL>) {}      

MsgData(const std::string* data)
 : type_(STRING_STD), data_((void*)data), deleter_(&deleter<std::string>) {}  

where deleter_ is a member:

std::function<void(void const*)>  deleter_;

and deleter is defined as function template:

template<typename T>
void deleter(void const * data) {
   delete static_cast<T const *>(data);
}

Once you have these, your destructor would look like this:

~MsgData() {
   if (deleter_) {
      deleter_(data_);
   }
}

Hope that helps.