Qual è l'uso di passare riferimenti const a tipi primitivi?

Question

In un progetto io sostengo, vedo un sacco di codice come questo per i metodi semplici get / set

const int & MyClass::getFoo() { return m_foo; }

void MyClass::setFoo(const int & foo) { m_foo = foo; }

Qual è il punto nel fare che invece di quanto segue?

int MyClass::getFoo() { return m_foo; }  // Removed 'const' and '&' 

void MyClass::setFoo(const int foo) { m_foo = foo; }  // Removed '&'

Il passaggio di un riferimento a un tipo primitivo dovrebbe richiedere lo stesso (o più) sforzo che passa il valore del tipo stesso, giusto?
E 'solo un numero, dopo tutto ...
Questo è solo un po 'tentato di micro-ottimizzazione o c'è un vero beneficio?

Answer 1

La differenza è che se si ottiene questo risultato in un punto di riferimento da soli è possibile tenere traccia delle modifiche della variabile membro intero nel proprio nome della variabile senza richiamare la funzione.

const &int x = myObject.getFoo();
cout<<x<<endl;
//...
cout<<x<<endl;//x might have changed

Non è probabilmente la scelta migliore progettazione, ed è molto pericoloso per restituire un riferimento (const o no), nel caso in cui una variabile che viene liberato dal campo di applicazione viene restituito. Quindi, se si torna un riferimento, fare attenzione per essere sicuri che non è una variabile che va fuori di portata.

C'è una leggera differenza per il modificatore troppo, ma ancora una volta probabilmente non qualcosa che vale la pena di fare o che è stato inteso.

void test1(int x)
{
  cout<<x<<endl;//prints 1
}

void test2(const int &x)
{
  cout<<x<<endl;//prints 1 or something else possibly, another thread could have changed x
}

int main(int argc, char**argv)
{
  int x = 1;
  test1(x);
  //...
  test2(x);
  return 0;
}

Quindi, il risultato finale è che si ottiene le modifiche anche dopo che sono passati i parametri.

Answer 2

Per me, il superamento di un di riferimento const per le primitive è un errore. O è necessario modificare il valore, e in tal caso si passa un di riferimento non-const , o non vi resta che accedere al valore e in questo caso si passa un const .

riferimenti Const deve essere utilizzato per le classi complesse, quando gli oggetti la copia potrebbe essere un problema di prestazioni. Nel caso di primitive, a meno che non è necessario modificare il valore della variabile non si dovrebbe passare un di riferimento . La ragione è che riferimenti richiedere più tempo di calcolo di non i riferimenti , dal momento che con riferimenti , il programma ha bisogno di guardare in un tavolo per trovare indirizzo dell'oggetto. Quando questo tempo di look-up è più breve del tempo di copia, i riferimenti sono un miglioramento.

Generalmente, int e indirizzi avere la stessa lunghezza byte nelle implementazioni di basso livello. Quindi il tempo di copia di un int come valore di ritorno di una funzione è equivalente al tempo di copia di un Indirizzo . Ma nel caso in cui un int viene restituito, non viene eseguita alcuna guardare in alto, quindi le prestazioni è aumentata.

Answer 3

La differenza principale tra restituire un valore e restituisce un riferimento const è che si può quindi const_cast che il riferimento e modificare il valore.

E 'un esempio di cattiva progettazione e un tentativo di creare un design intelligente in cui il design semplice e conciso sarebbe più che sufficiente. Invece di limitarsi a restituire un valore l'autore fa i lettori di codice a pensare quale intenzione che avrebbe potuto avere.

Answer 4

Non c'è molto beneficio. Ho visto questo in quadro o macro generato getter e setter prima. Il codice di macro non faceva distinzione tra i tipi primitivi e non-POD e appena usato const type& su tutta la linea per il setter. Dubito che si tratta di un problema di efficienza o di un vero e proprio equivoco; è probabile che questo è un problema di coerenza.

Answer 5

Credo che questo tipo di codice è scritto che hanno frainteso il concetto di riferimenti e usarlo per tutto, compreso i tipi di dati primitivi. Ho visto anche un po 'di codice come questo e non riesco a vedere alcun vantaggio di fare questo.

Answer 6

Non ha senso e benefici, tranne

void MyClass::setFoo(const int foo)
void MyClass::setFoo(const int& foo)

come allora non sarà in grado di riutilizzare all'interno implementazione 'pippo' variabile 'setFoo'. E credo che 'int &' è solo perché Guy solo abituarsi a passare tutte le cose con riferimento const e non c'è niente di sbagliato in questo.