2012-06-08 2 views
9

Sto imparando C++ e stavo leggendo il costruttore di copia da C++: The Complete Reference. I libri dicono cheCopia costruttore con più di un parametro

È consentito ad un costruttore di copia di avere parametri aggiuntivi purché abbiano argomenti predefiniti definiti per essi. Tuttavia, in tutti i casi il primo parametro deve essere un riferimento all'oggetto che esegue l'inizializzazione.

Ma sono confuso dal modo in cui passeremo questi parametri aggiuntivi? Sono sicuro che ci dovrebbe essere un modo che non è dato nel libro e che non sono in grado di capire. Qualcuno mi può aiutare?

EDIT: Inoltre è possibile passare questi parametri aggiuntivi in ​​tutti e tre i casi cioè

  • Quando un oggetto inizializza esplicitamente un altro, come ad esempio in una dichiarazione
  • Quando una copia di un oggetto viene fatto passare ad una funzione
  • Quando viene generato un oggetto temporaneo (più comunemente, come valore di ritorno)
+1

_I libri di Herbert Schildt_ sono [guardati in basso] (http://www.seebs.net/c/c_tcn4e.html) dalla [community] (http://stackoverflow.com/questions/18385418/c-meaning- di-un-dichiarazione-che combina-typedef-e-typename # comment26999919_18385418). È a causa della quantità di errori in ogni pagina, cattive pratiche che professa. [La Guida al libro e l'elenco dei libri C++ definitivi] (http://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list?rq=1) dovrebbe aiutarti a sceglierne uno valido. – legends2k

risposta

13

Ecco un semplice esempio:

class A { 
    //... 
public: 
    A (const A&, bool deep = false) { 
     if (!deep) { /* make a shallow copy */ } 
     else { /* make a deep copy */ } 
    } 
}; 

void foo (A x) { /*...*/ } 
A bar() { /*...*/ return A(); } 
A a_var; 

In questo esempio, il parametro è inadempiente su false, il che significa il costruttore di copia di default sarà poco profonda.

A b(a_var);  // b gets a shallow copy of a 
foo(b);   // foo() receives a shallow copy 

Tuttavia, sarebbe possibile effettuare una copia profonda passando true nel secondo parametro.

A b(a_var, true); // b gets a deep copy of a 
foo(A(b, true)); // foo receives a shallow copy of a deep copy 

Analogamente, per una funzione che restituisce un A, l'esemplare di rinvio sarebbe superficiale, in quanto utilizza il difetto, ma il ricevitore può rendere profonda quando riceve.

A b(bar());  // shallow 
A b(bar(), true); // deep 

Ricordate quando si definisce un costruttore di copia, è probabile che significa che sarà necessario definire un distruttore e sovraccaricare l'operatore di assegnazione (la regola del tre).

+0

e per quanto riguarda gli altri 2 casi, passando un oggetto ad una funzione in base al valore e restituendo un oggetto? ... ho aggiornato la domanda per lo stesso. –

+0

@RaviGupta: grazie per l'input, modifica apportata. – jxh

1

Pensateci in questo modo: c'è solo la nozione di costruttore. Quando il compilatore decide che è necessario eseguire una copia, cerca un costruttore che può essere chiamato passando un singolo oggetto di tipo T. A causa di questo caso d'uso speciale, chiamiamo convenzionalmente il costruttore scelto come costruttore "copia".

Problemi correlati