È legale in C++ 11? Compilare con l'ultimo compilatore Intel e sembra funzionare, ma ho la sensazione che sia un colpo di fortuna.Posizionamento nuovo basato sul modello sizeof()
class cbase
{
virtual void call();
};
template<typename T> class functor : public cbase
{
public:
functor(T* obj, void (T::*pfunc)())
: _obj(obj), _pfunc(pfunc) {}
virtual void call()
{
(_obj)(*_pfunc)();
}
private:
T& _obj;
void (T::*_pfunc)();
//edited: this is no good:
//const static int size = sizeof(_obj) + sizeof(_pfunc);
};
class signal
{
public:
template<typename T> void connect(T& obj, void (T::*pfunc)())
{
_ptr = new (space) functor<T>(obj, pfunc);
}
private:
cbase* _ptr;
class _generic_object {};
typename aligned_storage<sizeof(functor<_generic_object>),
alignment_of<functor<_generic_object>>::value>::type space;
//edited: this is no good:
//void* space[(c1<_generic_object>::size/sizeof(void*))];
};
In particolare mi chiedo se void* space[(c1<_generic_object>::size/sizeof(void*))];
realmente sta andando dare il formato corretto per gli oggetti membro di C1 (_obj e _pfunc). (Non lo è).
EDIT: Così, dopo qualche ricerca più sembrerebbe che il seguente sarebbe (più?) Corretto:
typename aligned_storage<sizeof(c1<_generic_object>),
alignment_of<c1<_generic_object>>::value>::type space;
Tuttavia su ispezione del assembly generato, utilizzando nuova collocazione con questo spazio sembra inibire la compilatore di ottimizzazione via la chiamata al 'nuovo' (che sembrava accadere durante l'utilizzo di solo regolare '_ptr = new c1;'
EDIT2: Cambiato il codice per fare un po 'più chiaro le intenzioni
Come si suppone che si possa compilare senza fornire un inizializzatore per un membro di riferimento in 'c1'? C'è qualche importanza specifica in quel membro di riferimento o no? – AnT
Inoltre, qual è l'idea alla base del calcolo della dimensione della memoria attraverso 'sizeof (_obj)', che valuta la dimensione dell'oggetto completo (cioè 'sizeof T'), ma poi costruisci un oggetto' c1 'in quel luogo, che fisicamente contiene solo un * riferimento * a 'some_type_t' (implementato come un puntatore)? –
AnT
Non so se compila o meno, è un esempio molto semplificato che ho fatto per postare qui per tagliare alle parti rilevanti. Sto scrivendo una classe signal/callback e desidero eliminare l'allocazione dinamica della memoria, se possibile. –