[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.

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ì.

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.

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

ciao