Come dichiarare un riferimento e inizializzarlo più tardi

Question

Sono molto nuovo in C++ e qui c'è la mia situazione. Ho un riferimento a MyOjbect, ma l'oggetto esatto dipende da una condizione. Allora voglio fare qualcosa di simile:

MyObject& ref; 
if([condition]) 
    ref = MyObject([something]) 
else 
    ref = MyObject([something else]); 

non posso farlo in questo momento perché il compilatore non mi permette di dichiarare, ma non inizializza un punto di riferimento. Cosa posso fare per raggiungere il mio obiettivo qui?

Answer 1

È necessario inizializzarlo. Ma se vuoi inizializzarlo condizionatamente, puoi fare qualcosa del genere:

MyObject& ref = (condition) ? MyObject([something]) : MyObject([something else]); 

Answer 2

In C++, non è possibile dichiarare un riferimento senza inizializzazione. È necessario inizializzarlo.

Answer 3

Risposta breve: non è così.

risposta marginalmente più: fare qualcosa di simile:

MyObject& getObject() 
{ 
    if([condition]) 
     return [something] 
    else 
     return [something else]; 
} 

MyObject& ref = getObject(); 

disclaimer usuali per quanto riguarda i riferimenti si applicano naturalmente.

Answer 4

Non è possibile farlo. I riferimenti devono essere legati a qualcosa, potrebbe non piacerti ma impedisce un'intera classe di errori, perché se hai un riferimento puoi sempre presumere che sia legato a qualcosa, a differenza di un puntatore che potrebbe essere nullo.

Il codice di esempio non funzionerebbe comunque perché si tenta di associare un riferimento non const a un oggetto temporaneo, che non è valido.

Perché è necessario che sia comunque un riferimento? Una soluzione potrebbe essere quella di assicurare il vostro tipo ha un costruttore di default poco costoso e può essere spostato in modo efficiente, quindi basta fare:

MyObject obj; 
if([condition]) 
    obj = MyObject([something]) 
else 
    obj = MyObject([something else]); 

In caso contrario si avrebbe dovuto mettere il codice condizionale in una o più funzioni, sia:

const MyObject& ref = createObject([condition]); 

o

const MyObject& ref = [condition] ? doSomething() : doSomethingElse(); 

Si noti che entrambe queste versioni utilizzano un const di riferimento , che può legarsi ad un temporanea, se il oggetto deve essere non-const, poi di nuovo smettere di cercare di utilizzare un riferimento:

MyObject obj = createObject([condition]); 

questo sarà probabilmente essere altrettanto efficace come quello che si stava tentando di fare, grazie alla return value optimization

Answer 5

per quanto ne so questo puo' essere fatto con un riferimento Dovresti utilizzare un puntatore:

MyClass *ptr; 

if (condition) 
    ptr = &object; 
else 
    ptr = &other_object; 

Il puntatore agirà come un riferimento. Non dimenticare di usare -> per l'accesso dei membri.

Answer 6

MyClass *ptr; 

if (condition) 
    ptr = &object; 
else 
    ptr = &other_object; 

MyClass &ref = *ptr; 

Answer 7

È possibile utilizzare parole chiave "extern": prima volta (assumere, nel file di intestazione) è possibile dichiarare la variabile precedente dichiarazione con la parola chiave "extern". Successivamente (nel file sorgente) si ripete la dichiarazione senza "extern" e si assegna un valore.