Come posso rendere questo oggetto C++ non copiabile?

Question

Vedere il titolo.

ho:

class Foo { 
    private: 
    Foo(); 
    public: 
    static Foo* create(); 
} 

Che bisogno che faccio da qui per fare Foo non-copiabile?

Grazie!

Answer 1

class Foo { 
    private: 
    Foo(); 
    Foo(const Foo& other); // non construction-copyable 
    Foo& operator=(const Foo&); // non copyable 
    public: 
    static Foo* create(); 
} 

Se stai usando spinta, è possibile anche ereditare da noncopyable: http://www.boost.org/doc/libs/1_41_0/boost/noncopyable.hpp

EDIT: C++ 11 versione se si dispone di un compilatore che supportano questa funzione:

class Foo { 
    private: 
    Foo(); 
    Foo(const Foo& other) = delete; // non construction-copyable 
    Foo& operator=(const Foo&) = delete; // non copyable 
    public: 
    static Foo* create(); 
} 

Answer 2

Rendi privato il costruttore della copia.

Foo(const Foo& src); 

Non è necessario implementarlo, basta dichiararlo nel file di intestazione.

Answer 3

Rende privato anche il costruttore di copie e l'operatore di assegnazione. Solo la dichiarazione è sufficiente, non è necessario fornire un'implementazione.

Answer 4

Il modo tipico per rendere un oggetto C++ non copiabile è dichiarare esplicitamente un costruttore di copia e un operatore di assegnazione delle copie ma non implementarli. Ciò impedirà al compilatore di generare il proprio. (In genere questo viene fatto in collaborazione con dichiarandoli private in modo da generare un errore di compilazione, invece di un errore di linker.)

C'è anche la classe boost::noncopyable che si può ereditare da, che fa quello che ho descritto sopra.

Answer 5

#include <boost/utility.hpp> 
class Foo : boost::noncopyable {... 

Ma come disse una volta Scott Meyers ... "È una bella classe, è solo che trovo il nome un po 'un, err non naturale", o qualcosa del genere.

Answer 6

Per aggiungere un po 'lì.

La soluzione tradizionale è, come si è detto, a dichiarare sia Copy Constructor e Assignment Operator come private, e non a definire loro.

• Perché sono private, questo porterà ad un errore di di compilazione da chiunque cerchi di usarli che non ha accesso alle parti private della classe ...
• Quale lascia amici (e la classe stessa) per cui si verificherà l'errore sotto forma di undefined symbol, a tempo di collegamento (se si verifica per quelli lì) o molto probabilmente a tempo di esecuzione (quando si tenta di caricare la libreria).

Naturalmente, nel secondo caso è piuttosto un problema perché è necessario verificare il proprio codice in quanto non si ha l'indicazione del file e della riga in cui si verifica l'errore. Fortunatamente è limitato ai metodi e agli amici della tua classe.

---

Inoltre, vale la pena notare che queste proprietà sono transitivi lungo la strada ereditarietà e composizione: il compilatore solo generare versioni predefinite del Default Constructor, il Copy Constructor, il Assignment Operator e Destructor se può.

Ciò significa che per ciascuno di questi quattro, vengono generati automaticamente solo se sono accessibili per tutte le basi e gli attributi della classe.

// What does boost::noncopyable looks like > 
class Uncopyable { 
public: 
    Uncopyable() {} 

private: 
    Uncopyable(const Uncopyable&); 
    Uncopyable& operator=(const Uncopyable&); 
}; 

Questo è il motivo per ereditare da questa classe (o di usarlo come attributo) sarà previene efficacemente la propria classe per essere copiabile o cedibile a meno che non si definiscono tali operatori da soli.

Generalmente ereditarietà è scelto sopra composizione per 2 motivi:

• l'oggetto è efficacemente Uncopyable, anche se il polimorfismo non può essere che utile
• Inheritance conduce EBO o Empty Base Optimization, mentre un attributo sarà indirizzabile e quindi occuperà memoria (in ogni istanza della classe) anche se in realtà non ne ha bisogno, il compilatore ha la possibilità di non aggiungere questo overhead per una classe base.

Si potrebbe, in alternativa, dichiarare gli operatori privati ​​e non li definisce nella propria classe, ma il codice sarebbe meno auto-documentazione, e non sarebbe in grado di ricercare automaticamente per quelli di classe che hanno questa proprietà quindi (a meno che tu non abbia un parser completo).

Spero che questo accenda il meccanismo.

Answer 7

Questo è quello che uso:

/* Utility classes */ 

struct NoCopy 
{ 
public: 
    NoCopy() {} 
private: 
    NoCopy(const NoCopy &); 
}; 

struct NoAssign 
{ 
private: 
    NoAssign &operator=(const NoAssign &); 
}; 

struct NonInstantiable 
{ 
private: 
    NonInstantiable(); 
}; 

struct NoCopyAssign : NoCopy, NoAssign 
{ 
}; 
typedef NoCopyAssign NoAssignCopy; 

Nel tuo caso:

struct Example : NoCopy 
{ 
}; 

Answer 8

Solo un altro modo per non consentire costruttore di copia, per comodità, una macro DISALLOW_COPY_AND_ASSIGN può essere utilizzato:

// A macro to disallow the copy constructor and operator= functions 
// This should be used in the private: declarations for a class 
#define DISALLOW_COPY_AND_ASSIGN(TypeName) \ 
    TypeName(const TypeName&) = delete;  \ 
    void operator=(const TypeName&) = delete 

Quindi, in classe Foo:

class Foo { 
public: 
    Foo(int f); 
    ~Foo(); 

private: 
    DISALLOW_COPY_AND_ASSIGN(Foo); 
}; 

ref from google style sheet

Answer 9

In C++ 11, è possibile disattivare in modo esplicito la creazione di copia predefinita e costruttore di assegnazione ponendo = delete dopo la dichiarazione.

Da Wikipedia:

struct NonCopyable { 
    NonCopyable() = default; 
    NonCopyable(const NonCopyable&) = delete; 
    NonCopyable & operator=(const NonCopyable&) = delete; 
}; 

Lo stesso vale per le classi di corso.