9

Ho un caso d'uso che il mio oggetto non deve essere copiato in alcun modo. Ho scritto una lista completa esagerata delle delezioni dell'operatore di copia e di assegnazione copia qui sotto. Ce ne sono così tanti che non posso essere sicuro di quali usare, ea volte questo mi rende paranoico. Non devo scriverli tutti nel mio codice, vero? Quindi, al fine di evitare qualsiasi tipo di copia di oggetti, quale di essi dovrei usare?Eliminazione dei costruttori di copie e copia degli operatori di assegnazione. Quali di questi sono essenziali?

 MyClass    (  MyClass &) = delete; 
     MyClass    (const MyClass &) = delete; 
     MyClass    (  MyClass &&) = delete; 
     MyClass    (const MyClass &&) = delete; 
     MyClass operator=(  MyClass &) = delete; 
     MyClass operator=(const MyClass &) = delete; 
const MyClass operator=(  MyClass &) = delete; 
const MyClass operator=(const MyClass &) = delete; 
     MyClass & operator=(  MyClass &) = delete; 
     MyClass & operator=(const MyClass &) = delete; 
const MyClass & operator=(  MyClass &) = delete; 
const MyClass & operator=(const MyClass &) = delete; 
     MyClass && operator=(  MyClass &) = delete; 
     MyClass && operator=(const MyClass &) = delete; 
const MyClass && operator=(  MyClass &) = delete; 
const MyClass && operator=(const MyClass &) = delete; 
     MyClass operator=(  MyClass &&) = delete; 
     MyClass operator=(const MyClass &&) = delete; 
const MyClass operator=(  MyClass &&) = delete; 
const MyClass operator=(const MyClass &&) = delete; 
     MyClass & operator=(  MyClass &&) = delete; 
     MyClass & operator=(const MyClass &&) = delete; 
const MyClass & operator=(  MyClass &&) = delete; 
const MyClass & operator=(const MyClass &&) = delete; 
     MyClass && operator=(  MyClass &&) = delete; 
     MyClass && operator=(const MyClass &&) = delete; 
const MyClass && operator=(  MyClass &&) = delete; 
const MyClass && operator=(const MyClass &&) = delete; 
+0

Questo vede un po 'paranoico in effetti :) – melak47

+4

Inoltre non verrà compilato, perché non è possibile sovraccaricare il valore restituito. – interjay

+3

Inoltre, hai dimenticato 'volatile' ;-) –

risposta

15

È sufficiente contrassegnare un costruttore di copia singola e copiare l'operatore di assegnazione come delete. La presenza delle versioni di copia impedirà la dichiarazione implicita del costruttore di movimento e dell'operatore di spostamento, e la dichiarazione di una forma di una funzione di membro speciale di copia sopprime la dichiarazione implicita di altre forme.

MyClass (const MyClass&) = delete; 
MyClass& operator= (const MyClass&) = delete; 

nota che il post-C++ 11, implicita definizione dell'operatore di assegnazione come stabilizzato è obsoleto e dovrebbe invece essere definito come eliminati.

+1

Solo un nitpick molto leggero, e potrei sbagliarmi. La * definizione * non è deprecata, non la * dichiarazione *? Vengono sempre dichiarati, ma la loro definizione viene cancellata. Ma io non sono un ottimo avvocato linguistico. – luk32

+0

@ luk32 ah, sei corretto, dovrebbe invece essere implicitamente dichiarato e definito come cancellato, ('[class.copy]/18'), grazie. – TartanLlama

3

copy constructor

MyClass    (const MyClass &) = delete; 

assignement operator

MyClass & operator=(const MyClass &) = delete; 

Questi sono gli unici costruttori di copia ans copiare operatori assignement implicitamente definito.

+2

' operator = 'non è un costruttore; e in generale altri costruttori possono essere definiti implicitamente - ma la presenza di 'MyClass (const MyClass &)' definita dall'utente sopprime gli altri costruttori. –

+3

La tua "soluzione" è buona, ma la risposta è in realtà sbagliata. Il ragionamento appropriato è che tutti gli operatori ei costruttori di assegnazioni sono definiti implicitamente a meno che, tra le altre ragioni, ne definisca uno a mano. La cancellazione conta come definizione per questo scopo. – luk32

Problemi correlati