Riferimento C++ e puntatori const in C/C++

Question

Recentemente mentre stavo spiegando a qualcuno la differenza di base tra riferimenti e puntatori (nel contesto della programmazione C++), ho detto le solite spiegazioni che parlano di argomenti di funzione differenti che passano le convenzioni - Call by valore, Call by pointer, Call by reference e tutta la teoria associata sui riferimenti.

Ma poi ho pensato a qualsiasi cosa faccia un riferimento C + in termini di passaggio di argomenti, (Consente un modo efficiente di memoria di passare strutture/oggetti di grandi dimensioni, allo stesso tempo lo mantiene sicuro non permettendo al destinatario di modificare alcuna variabile dell'oggetto passato come riferimento, se il nostro design lo richiede)

Un puntatore const in C otterrebbe la stessa cosa, ad esempio Se bisogna passare un puntatore struttura dire struct mystr * ptr, colando il puntatore struttura come costante -

func(int,int,(const struct mystr*)(ptr)); 

sarà non PTR essere una sorta di equivalente a un riferimento?

1. Will non funziona nel modo che sarebbe memoria efficiente non replicare la struttura (passaggio per puntatore), ma anche sicuro vietando qualsiasi modifica dei campi di struttura per il fatto che esso è passato come un puntatore const.

   Nel contesto di oggetto C++, si può passare puntatore const oggetto invece riferimento a un oggetto come ottenere stessa funzionalità)

2. Se sì, allora lo scenario che cosa caso d'uso in C++, ha bisogno di riferimenti. Eventuali vantaggi specifici dei riferimenti e dei relativi inconvenienti?

grazie.

-AD

Answer 1

ci sono due tipici scenari casi d'uso:

Prime: Indicatori denotano argomenti opzionali. Poiché, i riferimenti non possono essere NULL, ma i puntatori possono, documentare nello stile di codifica che qualsiasi argomento che è indicato come puntatore, può essere NULL, la funzione deve gestirlo. Gli argomenti facoltativi possono quindi essere const o non-const, come possono gli argomenti (di riferimento) obbligatori.

Secondo: i riferimenti vengono utilizzati solo in combinazione con la parola chiave const, poiché la sintassi di chiamata suggerisce la semantica del lettore pass-by-value, che è per definizione costante.Quindi i puntatori vengono utilizzati solo per argomenti che possono essere modificati dal destinatario.

Personalmente preferisco la prima opzione, perché ognuno dei quattro casi "riferimento const", "riferimento non const", "puntatore const", "puntatore non const" ha un significato diverso. L'opzione due distingue solo tra due "cose": "la funzione può modificare quel valore" contro "la funzione non modificherà quel valore".

Answer 2

è possibile associare un riferimento const a un rvalue:

void foo(const std::string& s); 

foo(std::string("hello")); 

ma è impossibile passare l'indirizzo di un rvalue:

void bar(const std::string* s); 

bar(&std::string("hello")); // error: & operator requires lvalue 

I riferimenti sono stati introdotti in la lingua per supportare l'overloading dell'operatore. Vuoi essere in grado di dire a - b, non &a - &b. (Si noti che quest'ultimo ha già un significato:. Puntatore sottrazione)

Riferimenti principalmente supportano passaggio per riferimento, puntatori principalmente supportano semantica di riferimento. Sì, lo so, la distinzione non è sempre abbastanza chiara in C++.

Answer 3

In termini di oggetto referente, quale codice può essere manipolato dato un riferimento const è lo stesso di quello che può fare con un puntatore a un oggetto const e, analogamente, ciò che può manipolare dato un riferimento non const è lo stesso dato un puntatore a un oggetto non const.

Quale riferimento impedisce alla funzione chiamata di eseguire è modificare a quale oggetto si riferisce il riferimento o l'aritmetica del puntatore sul riferimento.

In termini di chiamante, un riferimento const può essere associato direttamente a un valore rvalue e la semantica è ben definita durante la creazione e la distruzione di oggetti passati come argomenti. Questo è un linguaggio comune - costruire un temporaneo per argomento:

// declaration 
void bar (const Foo&); 

// use 
bar (Foo()); 

Ma non è immediatamente evidente che l'oggetto Foo in questi ha una durata che supera la lunghezza della chiamata di funzione:

// declaration 
void bar (const Foo*); 

// use 
Foo temp; 
bar (&temp); 

// cast to avoid warning about taking address of temporary 
bar (&static_cast<const Foo&>(Foo())); 

// helper function to same effect 
template<typename T> const T* address_of (const T& t) { return &t; } 

bar (address_of (Foo())); 

Sebbene ovviamente quest'ultimo, essendo solo una chiamata di funzione, dovrebbe renderlo evidente lo fa.

Fondamentalmente, i riferimenti sono zucchero sintattico per puntatori che puntano a singoli oggetti, non all'inizio di matrici.