Destructores de tipos incorporados (int, char, etc.)

En C ++, el siguiente código da un error de comstackción:

void destruct1 (int * item) { item->~int(); } 

Este código es casi el mismo, simplemente escribo el int a otro tipo y sucede algo mágico:

 typedef int myint; void destruct2 (myint * item) { item->~myint(); } 

¿Por qué funciona el segundo código? ¿Un int obtiene un destructor solo porque ha sido typedefed?

En caso de que se pregunte por qué alguna vez le gustaría hacer esto: Esto proviene de la refactorización del código C ++. Estamos eliminando el montón estándar y reemplazándolo con grupos propios. Esto requiere que llamemos colocación nueva y los destructores. Sé que llamar a los destructores para tipos primitivos es inútil, pero queremos que estén en el código, sin embargo, en caso de que más adelante sustituyamos los POD por clases reales.

Descubrir que las int. Desnudas no funcionan, pero las de tipo typedefed lo hicieron fue una gran sorpresa.

Por cierto, tengo una solución que implica plantillas de funciones. Simplemente tipeamos dentro de la plantilla y todo está bien.

Es la razón por la que su código funciona para parámetros generics. Considere un contenedor C:

 template struct C { // ... ~C() { for(size_t i = 0; i 

Sería molesto introducir casos especiales para tipos incorporados. Entonces C ++ te permite hacer lo anterior, incluso si T pasa a ser igual a int . El santo estándar dice en 12.4 p15 :

La notación para llamada explícita de un destructor se puede usar para cualquier nombre de tipo escalar. Permitir esto hace posible escribir código sin tener que saber si existe un destructor para un tipo dado.

La diferencia entre usar un int simple y un typedef'ed int es que son cosas sintácticamente diferentes. La regla es que en una llamada de destructor, lo que está después de ~ es un nombre de tipo. int no es tal cosa, pero es un typedef-name. 7.1.5.2 en 7.1.5.2 .