Re: inhibit compiler warning C4624 for a class hierarchy
You mean you are slicing? As in
class B {
~B() {}
public:
void DeleteMe() { delete this; }
};
class D : public B {};
D* pD = new D;
pD->DeleteMe();
Yup, that's the essence.
In this case, your program exhibits undefined behavior for a different
reason:
5.3.5/3 In the first alternative (delete object), if the static type of
the operand is different from its dynamic type, the static type shall be a
base class of the operand's dynamic type and the static type shall have a
virtual destructor or the behavior is undefined.
Oh why do they have to use such unfriendly terms like "undefined behavior"?
How about just, "no destructors in derived classes will be executed". I
suppose the MI case would be bad, because the compiler would have to pass
the pointer for the entire object to operator delete(), rather than the base
subobject.
I'd really like to just pretend that the dynamic type is the base class. I
was just using the fact that constructors and (1) implicitly defined, (2)
automatically call the base class operator new with the actual most-derived
size, (3) automatically call the base class constructor, (4) allow me to
predefine arguments to the base class constructor if desired. None of the
constructors can throw. Maybe I need to switch to a template-based
allocator/deallocator and not call constructor or destructor at all.
Here's part of my existing hierarchy (there are many more codes than shown):
/**
** \brief
** Carries a request or notification and any associated parameters.
**
** Basic unit of information exchange for non-blocking operations using
** I/O dispatcher, carrying a request or notification and any associated
** parameters.
**
** Since OpMessages are passed between threads using OS primitives
** (on Microsoft Windows, window messages in a message queue, and
** custom queues synchronized by kernel event objects), which do not
** participate in garbage collection, custom allocation is needed.
**
** Providing a common base class allows centralized allocation which
** would ease the implementation of block pooling and/or allocation
** tracking in unit tests to verify absence of memory leaks.
**
** Future work:
** Use per-thread heap to avoid locking
** Delete from same thread as allocate
** For cross-thread messages, use an squeue<void*> to send buffers back
to
** original thread
**/
struct PNPEXPORT IConcurrentOperations::OpMessage abstract
{
public:
/**
** \brief custom allocator for operational messages
**
** \param[in] bytes number of bytes requested
** \return pointer to a block of (at least) size bytes, or NULL if
insufficient memory if available
**/
static void* operator new(size_t bytes)
{
return malloc(bytes);
}
size_t reservedbytes() const { return 0; }
protected:
/**
** \brief custom deallocator for operational messages
**
** \param[in] p pointer to memory block to be freed
**/
static void operator delete(void* p)
{
free(p);
}
};
struct PNPEXPORT IConcurrentOperations::OpNotification abstract : public
OpMessage
{
public:
/**
** \brief differentiation of notification types
**
** switch statement is preferred here over visitor pattern because
** not all request types are predefined, so visitor interface cannot
** be defined. Acyclic vistor pattern could be used but would involve
** additional virtual calls and dynamic_cast overhead.
**/
const DWORD NotificationType;
const CppDateTime NotificationTime;
protected:
OpNotification(DWORD dwType) throw() : NotificationType(dwType),
NotificationTime(CppDateTime::Now()) {}
private:
~OpNotification() {}
public:
/**
** \brief Frees resources used by this request
**/
void Destroy( void )
{
delete this;
}
};
template<DWORD NotificationTypeConst>
struct PNPEXPORT IConcurrentOperations::Notification abstract : public
OpNotification
{
protected:
/**
** \brief Constructor, marks the correct NotificationType
**/
Notification() throw() : OpNotification(NotificationTypeConst) {}
};
struct IConcurrentOperations::OpCloseAcknowledgement sealed
: public Notification<OpMessageTypes::CloseAcknowledgement> {};
struct IConcurrentSerialOperations::OpSerialErrorNotification sealed
: Notification<OpMessageTypes::SerialErrorNotification>
{
DWORD dwErrors;
};
struct IConcurrentSerialOperations::OpSerialEventNotification sealed
: Notification<OpMessageTypes::SerialEventNotification>
{
DWORD dwEvents;
};