How is that possible that it is allowed to delete object with private destructor in the following code? I've reduced real program to the following sample, but it still compiles and works.
class SomeClass;
int main(int argc, char *argv[])
{
SomeClass* boo = 0; // in real program it will be valid pointer
delete boo; // how it can work?
return -1;
}
class SomeClass
{
private:
~SomeClass() {}; // ! private destructor !
};
You are trying to delete object of incomplete class type. C++ Standard says that you'll get undefined behavior in this case (5.3.5/5):
If the object being deleted has incomplete class type at the point of deletion and the complete class has a non-trivial destructor or a deallocation function, the behavior is undefined.
To detect such cases you could use boost::checked_delete:
template<typename T>
inline void checked_delete( T* p )
{
typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
(void) sizeof(type_must_be_complete);
delete p;
}
sizeof to an incomplete type. This is what the above code is trying to catch by (void) sizeof ... part. This expression shall stop compilation on a compiler that complies to the standard by issuing an error. However, if some strange compiler happens to allow sizeof on incomplete types (as an extension) with 0 result, then the typedef ... part will catch those and force "an array of negative size" failure. So, you have a main "trap" here (the (void) part) and auxiliary trap "just in case" (the typedef part). –
Partition sizeof to an incomplete type. So, if some C compilers return 0 in this case, it is their own extension that has little to do with C language. –
Partition sizeof for empty struct is nonzero. C Standard doesn't guarantees that, but C++ Standard does. –
Japonica struct X {}; is empty and it causes compilation error (or, more formally, "diagnostic message") on any compliant C compiler. Because, as I said above, C does not allow empty structs. –
Partition struct X{}; is invalid in Standard C. I've compiled it in gcc and it doesn't warned me about an error. –
Japonica This code causes undefined behavior (UB). It is UB in C++ to delete an object of incomplete type having a non-trivial destructor. And in your code the type SomeClass is incomplete at the point of delete, and it has a non-trivial destructor. Compilers usually issue a warning about this, since in C++ formally this is not a constraint violation.
So, strictly speaking, your code doesn't "work". It simply compiles and does something undefined when run.
The compiler is just not required to catch this error. The reason for this is that this could be perfectly fine if your object has a trivial destructor. The compiler has no way of knowing what kind of destructor this type will eventually have, so it can't say for sure whether this is an error or not.
T has a trivial destructor (2) T doesn't redefine `delete operator`` –
Where Because SomeClass type is not completely declared when invoking operator delete.
Deleting such a pointer is undefined behavior, but in practice most compilers would just free the memory (if the pointer was non-NULL) and not call the destructor.
For example, g++ will give you a warning about this issue:
foo.cpp: In function 'int main(int, char**)':
foo.cpp:6: warning: possible problem detected in invocation of delete operator:
foo.cpp:5: warning: 'boo' has incomplete type
foo.cpp:1: warning: forward declaration of 'struct SomeClass'
foo.cpp:6: note: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined.
© 2022 - 2024 — McMap. All rights reserved.
warning C4150: deletion of pointer to incomplete type 'SomeClass'; no destructor called– MitzimitzieSomeClass. – Partition