Perché non riferimento non const a oggetti temporanei?

Question

C++ consente l'assegnazione di oggetti temporanei solo al riferimento const. Non consentirà l'assegnazione di oggetti temporanei a riferimento.

Ad esempio:

String& a = String("test");   // Error 
const String& a = String("test"); // Ok 

Ovunque Google per questo risultato, vedo solo le seguenti risposte

1. Modifica oggetti temporanei causerebbe problemi non identificabili
2. Modifica oggetti temporanei è pericoloso
3. Ad un certo punto del tempo, ti dimenticherai che è una variabile temporanea

Si è detto, gli oggetti temporanei svaniscono dopo la dichiarazione. Quindi non dovresti modificarlo.

Se C++ è così appassionato nel bloccare la modifica degli oggetti temporanei, dovrebbe aver bloccato la lettura degli oggetti temporanei giusto? Se l'oggetto temporaneo è sparito, non ha senso leggere i contenuti da lì giusto? I casi possibili, in cui può verificarsi un diritto, potrebbero anche comportare la lettura.

Quindi perché ha bloccato la scrittura da sola e consentendo la lettura?

Per favore dammi una spiegazione del codice C++ solido.

Si prega di non deviare la domanda indicando alcune alternative. Per favore, dammi una risposta valida con il codice perché const int & è consentito e int & non è consentito per oggetti temporanei.

Uno dice & & è lì .. La mia domanda diversa .. altro dire, cambiando non rifletterà .. La modifica non rifletterà anche quando è const int & troppo. Ad esempio: doppio a; Const int & i = a; a ++; non influenza i ..

Answer 1

Se si dispone di un oggetto temporaneo molto costoso da copiare, è preferibile prendere un const& per quell'oggetto (ad esempio una funzione di ritorno) anziché copiarlo in un'altra variabile da utilizzare in un secondo momento. Prendendo un riferimento costante a un temporaneo estende la vita di quel temporaneo fino a quando il riferimento vive, permettendoti di accedere a qualsiasi stato leggibile.

La scrittura non è consentita perché non appena si desidera modificare una variabile si può anche avere un'istanza reale piuttosto che una temporanea che è alias solo come riferimento non const.

Answer 2

Il caso originale per non consentire riferimenti a provvisori era per i parametri di funzione. Supponiamo che questo fosse permesso:

void inc(double& x) 
{ x += 0.1; } 

int i = 0; 
inc(i); 

Perché non è stato modificato i?

Answer 3

C'è una ragione logica per questo. Pensa, cosa vuoi in questa riga:

String& a = String("test");   // Error 

Vuoi un riferimento. Un riferimento si riferisce all'oggetto a cui fa riferimento. Come un indirizzo dell'oggetto (sebbene i riferimenti non siano indirizzi, rende la spiegazione più chiara in questo modo).In realtà provi a ottenere qualcosa come un indirizzo di String("test"). Ma quell'oggetto svanirà proprio sulla riga successiva, quindi qual è il punto del suo indirizzo, se l'oggetto a cui punta non esiste? a ora punta a qualcosa di insignificante ...

Per quanto riguarda la seconda domanda, qual è il punto di consentire tutti gli oggetti temporanei complessivamente, beh, non c'è niente di sbagliato in questo. Si consideri, ad esempio, il caso in cui si desidera passare un oggetto String a una funzione, che restituisce, ad esempio, una stringa modificata corrispondente a tale stringa. Chiamiamo la funzione DoubleString, così invece di fare

String s("hello "); 
String s2 = DoubleString(s); 

È possibile utilizzare una più breve, più conveniente forma

String s2 = DoubleString(String("hello ")); 

Sede, l'oggetto temporaneo String("hello ") sopravvive l'intera riga di codice, che significa che è intatto quando inviato a DoubleString e dopo di esso. Viene distrutto solo quando l'intera linea è finita.

Answer 4

Se C++, è così acuto a bloccare modificando gli oggetti temporanei, avrebbe dovuto bloccato lettura degli oggetti temporanei giusto? Se l'oggetto temporaneo è sparito, non ha senso leggere i contenuti da lì giusto?

No, leggere l'oggetto è perfettamente ragionevole. Solo perché sta per svanire in futuro non significa leggere i dati ora è inutile.

open_file(std::string("foo.txt")); 

std::string("foo.txt") è una temporanea che si fermerà esistente dopo la chiamata a open_file() ma i dati in esso contenuti, mentre esiste questioni molto.

Il razionale per non consentire i vincoli temporali ai riferimenti non costanti non è in realtà un problema fondamentale con la scrittura nei provvisori. Infatti in molti luoghi C++ è perfettamente felice di consentire provvisori da modificare:

std::string("foo") = "bar"; 

E 'solo che i progettisti hanno ritenuto che avrebbe causato un numero sufficiente di problemi (probabilmente a causa del linguaggio comune di 'parametri out') senza abilitare nulla di simile valore, quindi hanno semplicemente preso una decisione progettuale per vietare i vincoli temporali ai riferimenti non const.

Con riferimenti rvalue ora si può fare esattamente ciò che è stato proibito prima:

void foo(int &&output) { 
    output = 1; 
} 

foo(2); 

Questo funziona bene, non solo è molto utile.