[C++] Non ho capito una cosa

[Alex_87_xelA]

Ciao a tutti ... spero che mi possiate dare una mano per comprendere questa cosa alquanto strana (per me).

Parto con questo esempio per far capire il mio problema


template <class T>
class Allocator
{
public:
inline Allocator() { cout << "Costruttore Allocatore\n"; };
inline ~Allocator() { cout << "Distruttore Allocatore\n"; };

inline T *Alloca(const size_t &n) const
{
cout << "Alloca()\n";
return (T *)operator_new(n * sizeof(T));
}

inline void Dealloca(void *const ptr) const
{
cout << "Dealloca()\n";
operator_delete(ptr);
}

inline void Costruisci(T *const ptr, const T &val) const
{
cout << "Costruisci()\n";
new(ptr) T(val);
}

inline void Distruggi(T *const ptr) const
{
cout << "Distruggi()\n";
ptr->~T();
}

private:
inline void *operator_new(size_t n_bytes) const
{
return ::operator new(n_bytes);
}

inline void operator_delete(void *const ptr) const
{
::operator delete(ptr);
}
};

void prova()
{
Allocator<int> a;
int *num = a.Alloca(1);

a.Costruisci(num, 10);
cout << *num << endl;
a.Distruggi(num);

a.Dealloca(num);
}

int main()
{
prova();

_getch();
return 0;
}


l'esempio è semplice ... ma c'è una cosa che non capisco, e precisamente è quello he ho messo in grassetto.

come è possibile che l'istruzione contenuta nella funzione DISTRUGGI ... applicata ad un puntatore a intero non da errori !!!

per la precisione la funzione a cui mi riferisco è questa


inline void Distruggi(T *const ptr) const
{
cout << "Distruggi()\n";
ptr->~T();
}


questa funzione chiama il distruttore dell'oggetto passato ... quindi se passo un tipo strutturato che ha costruttore distruttore etc... la funzione chiamerà il distruttore su tale oggetto ... ma se il tipo è semplice .... cosa chiama ???? boh !!!

nell'esempio di sopra
template <class T>
viene interpretato come :
template<class T = int>

e quindi la funzione risulterebbe :


inline void Distruggi(int *const ptr) const
{
cout << "Distruggi()\n";
ptr->~int();
}


???? no ???? o sbaglio ???

quindi incuriositomi ho fatto quest'esempio :

int main()
{
int *ptr = new int;
ptr->~int();
delete ptr;

_getch();
return 0;
}


e OVVIAMENTE (come mi aspettavo) il compilatore mi da un sacrosanto ERRORE.

Mi spiegate il perchè plese ?

[DanieleC88]

Non sono un grande esperto di C++, ma credo che la richiesta esplicita di distruggere un intero ti dia un errore in fase di compilazione, mentre la stessa richiesta tramite i template (caso in cui non puoi sapere a priori che distruttore andrai a chiamare) viene filtrata dal compilatore. Nel tuo caso, se è un intero, il compilatore si limita a non distruggere niente. :D

Ho provato a disassemblare il tuo programmino nel caso in cui usi un int:
080489ee <_ZNK9AllocatorIiE9DistruggiEPi>:
80489ee: 55 push %ebp
80489ef: 89 e5 mov %esp,%ebp
80489f1: 83 ec 18 sub $0x18,%esp
80489f4: c7 44 24 04 68 8b 04 movl $0x8048b68,0x4(%esp)
80489fb: 08
80489fc: c7 04 24 20 9f 04 08 movl $0x8049f20,(%esp)
8048a03: e8 e8 fc ff ff call 80486f0 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt>
8048a08: c9 leave
8048a09: c3 ret

E nel caso in cui usi un std::string:
08048c1a <_ZNK9AllocatorISsE9DistruggiEPSs>:
8048c1a: 55 push %ebp
8048c1b: 89 e5 mov %esp,%ebp
8048c1d: 83 ec 18 sub $0x18,%esp
8048c20: c7 44 24 04 ad 8d 04 movl $0x8048dad,0x4(%esp)
8048c27: 08
8048c28: c7 04 24 c0 a1 04 08 movl $0x804a1c0,(%esp)
8048c2f: e8 fc fb ff ff call 8048830 <_ZStlsISt11char_traitsIc
EERSt13basic_ostreamIcT_ES5_PKc@plt>
8048c34: 8b 45 0c mov 0xc(%ebp),%eax
8048c37: 89 04 24 mov %eax,(%esp)
8048c3a: e8 01 fc ff ff call 8048840 <_ZNSsD1Ev@plt>
8048c3f: c9 leave
8048c40: c3 ret
8048c41: 90 nop

Quello che vedi è il codice della Distruggi() senza ottimizzazioni. Nel primo caso manca del tutto il seguente codice, che nel secondo caso è presente:
8048c34: 8b 45 0c mov 0xc(%ebp),%eax
8048c37: 89 04 24 mov %eax,(%esp)
8048c3a: e8 01 fc ff ff call 8048840 <_ZNSsD1Ev@plt>

Questo dovrebbe chiamare il codice del distruttore per la classe std::string. Non ne ho la certezza, ma secondo logica dovrebbe essere così. :D

ciao ;)

[Alex_87_xelA]

grazie mille della risposta ... e soprattutto del tempo che hai dedicato per rispondermi.

penso che tu abbia ragione ... ma non capisco perchè nei libri non trattano il seguente argomento (anche abbastanza banale, ma decisamente UTILE)

GRAZIE ANCORA

[DanieleC88]

Ma figurati... m'avevi fatto venire il dubbio pure a me e San Google non ha voluto aiutarmi, quindi ho deciso di indagare da solo. :D

Penso che nei libri saltino alcuni dettagli che credono ovvi o deducibili, altrimenti sarebbero tutti mattoni enormi. :)

ciao ;)