Why exactly is this template function successfully compiling?

Question

Possible Duplicate:
Destructors of builtin types (int, char etc..)

Template Function:

template<typename T> void kill(T* type)
{
    type->~T();
}

Call:

int x= 5;
kill(&x);

woah, it compiled!? How can a primitive type like int have a destructor? It is also working with char , bool etc.

kill!!! I'm a homicidal maniac. – ApprenticeHacker Jan 24 '12 at 05:54 — ApprenticeHacker, Jan 24 '12 at 05:54
Okay--changed the `destroy` to `kill` above. – sblom Jan 24 '12 at 05:55 — sblom, Jan 24 '12 at 05:55
lol, I didn't notice that. thanks. – ApprenticeHacker Jan 24 '12 at 05:56 — ApprenticeHacker, Jan 24 '12 at 05:56

score 4 · Accepted Answer · answered Jan 24 '12 at 05:59

4

§12.4.16 of the Standard says

16 [ Note: the notation for explicit call of a destructor can be used for any scalar type name (5.2.4). Allowing this makes it possible to write code without having to know if a destructor exists for a given type. For example,
typedef int I;
I* p;
p->I::~I();
—end note ]

answered Jan 24 '12 at 05:59

Seth Carnegie

73,875
22
181
249

so the compiler ignores any call to the destructor of a scalar type? – ApprenticeHacker Jan 24 '12 at 06:01
@IntermediateHacker whether it specially ignores them or just sees that they do nothing and leaves them out of the code, the effect is the same. It's a feature probably specifically meant for making it easier to write templates (though I can only guess; I don't know if this feature was there before C++ had templates). Also btw, your code exhibits undefined behaviour because the integer is destructed twice :) – Seth Carnegie Jan 24 '12 at 06:03
@SethCarnegie: There is no undefined behavior due to multiple pseudo-destructor calls. The only effect will be evaluation of expression before `.` or `->`. Moreover, there seems to be no UB for multiple calls of trivial destructors for the same object. – Konstantin Oznobihin Jan 24 '12 at 06:24

score 1 · Answer 2 · answered Jan 24 '12 at 06:13

The relevant part of the standard is §5.2.4/1:

The use of a pseudo-destructor-name after a dot . or arrow -> operator represents the destructor for the non-class type named by type-name. The result shall only be used as the operand for the function call operator (), and the result of such a call has type void. The only effect is the evaluation of the postfix expression before the dot or arrow.

Why exactly is this template function successfully compiling?

2 Answers2