C++: durata di un oggetto e funzioni esterne

Question

Supponiamo di voler chiamare una funzione esterna dell'oggetto per eseguire alcuni controlli all'interno del costruttore del corpo. Poiché la vita di un oggetto inizia quando il corpo del costruttore termina la sua esecuzione, si tratta di un design non sicuro?

struct A; 

void check(A const&) { /* */ } 

struct A 
{ 
    A() { check(*this); } 
}; 

Voglio dire, sto chiamando e funzione esterna con un oggetto non ancora vivo. È un comportamento indefinito?

Domande correlate: se metto quella funzione il controllo come una funzione di membro (statico o no), che cosa lo standard dice sull'utilizzo di oggetti non-ancora-vivi al di fuori del costruttore, ma all'interno della classe?

C'è qualche differenza nel concetto di durata tra il punto di vista di una classe e i suoi utenti (una specie di vita in classe rispetto alla classe esterna)?

Answer 1

La durata di A non avrà iniziato quando check() si chiama perché, da [base.life]:

La durata di un oggetto di tipo T inizia quando:

• storage con si ottiene l'allineamento e le dimensioni corrette per il tipo T e
• se l'oggetto ha un'inizializzazione non vuota, la sua inizializzazione è completa.

A ha inizializzazione non vuota. La sua inizializzazione è completa quando, dal [class.base.init]/13:

In un costruttore non delega, procede inizializzazione nel seguente ordine:

• ...
• - Infine, viene eseguita l'istruzione composta del corpo del costruttore.

Tuttavia, nonostante A non essendo la sua vita è ancora iniziato, lo standard prevede inoltre, in [class.base.init]/16:

funzioni membri (comprese le funzioni membro virtuali, 10.3) può essere chiamato per un oggetto in costruzione ... Tuttavia, se queste operazioni vengono eseguite in un ctor-inizializzatore (o in una funzione chiamata direttamente o indirettamente da un ctor-inizializzatore) prima che tutti i mem- initi alizers per le classi base completate, il risultato dell'operazione non è definito.

Per quanto riguarda i problemi di durata, non c'è alcuna differenza tra:

void check(const A&) { .. } 
struct A { 
    A() { check(*this); } 
}; 

E:

struct A { 
    void check() const { .. } 
    A() { check(); } 
}; 

Quest'ultimo è esplicitamente consentito (in quanto non è in un ctor-initializer), quindi non vedo alcun motivo per escludere il primo per motivi di vita.