Как сделать этот объект C++ не скопированным?

Question

См. Название.

у меня есть:

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

Что нужно делать здесь, чтобы сделать Foo ун-копируемыми?

Спасибо!

Answer 1

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

Если вы используете импульс, вы можете наследовать от noncopyable: http://www.boost.org/doc/libs/1_41_0/boost/noncopyable.hpp

EDIT: C++ 11 версию, если у вас есть компилятор, поддерживающий эту функцию:

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

Сделать конструктор копии закрытым.

Foo(const Foo& src); 

Вам не нужно его реализовывать, просто объявите его в файле заголовка.

Answer 3

Сделайте также конструктор копирования и оператор присваивания. Просто объявления достаточно, вам не нужно предоставлять реализацию.

Answer 4

Типичный способ сделать объект C++ несовместимым - это явно объявить конструктор копирования и оператор присваивания копий, но не реализовать их. Это предотвратит создание компилятором собственного. (Обычно это делается в сочетании с объявлением их private, чтобы он генерировал ошибку компиляции вместо ошибки компоновщика.)

Также существует класс boost::noncopyable, из которого вы можете наследовать, что делает то, что я описал выше.

Answer 5

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

Но Скотт Мейерс однажды сказал ... «Это классный класс, просто я нахожу имя немного un, err non natural» или что-то в этом роде.

Answer 6

Чтобы добавить немного туда.

Традиционное решение, как уже было сказано, чтобы объявить как Copy Constructor и Assignment Operator как private и не к определить их.

• Поскольку они private, это приведет к времени компиляции ошибки в от тех, кто пытается использовать их, что не доступ к закрытым частям класса ...
• который оставляет друзей (и сам класс), для которого ошибка будет возникать в форме undefined symbol, либо на link-time (если вы проверяете их там), либо, скорее всего, в времени выполнения (при попытке загрузить библиотеку).

Конечно, во втором случае это беспокоит вас, потому что вам необходимо проверить свой код самостоятельно, так как у вас нет указаний на файл и строку, в которой происходит ошибка. К счастью, это ограничено вашими методами и друзьями.

---

Кроме того, стоит отметить, что эти свойства транзитивным вниз наследования и композиции дороги: компилятор будет генерировать только версии Default Constructor по умолчанию, то Copy Constructor, то Assignment OperatorDestructor и если оно может.

Это означает, что для любого из четырех они автоматически генерируются только, если они доступны для всех баз и атрибутов класса.

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

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

Вот почему наследование от этого класса (или использовать его в качестве атрибута) будет эффективно предотвращает собственный класс быть копируемыми или переуступкой, если не определить эти операторы сами.

В общем случае наследования выбирается над композицией там по 2 причинам:

• Объект эффективно Uncopyable, даже если полиморфизм может не быть, что полезно
• Наследование приводит к EBO или Empty Base Optimization, в то время как атрибут будет адресуемый и, таким образом, будет занимать память (в каждом экземпляре класса), даже если он на самом деле не нужен, компилятор имеет возможность не добавлять эти служебные данные для базового класса.

Вы могли бы, в качестве альтернативы, объявить операторы приватного и не определять их в своем собственном классе, но код будет меньше самодокументирующийся, и вы не смогли бы автоматически искать тот класс, которые имеют это свойство тогда (если у вас нет полноразмерного анализатора).

Надеюсь, что это пролить свет на механизм.

Answer 7

Это то, что я использую:

/* 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; 

В вашем случае:

struct Example : NoCopy 
{ 
}; 

Answer 8

Просто еще один способ запретить конструктор копирования, Для удобства DISALLOW_COPY_AND_ASSIGN макрос может быть использован:

// 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 

Затем, в классе Foo:

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

private: 
    DISALLOW_COPY_AND_ASSIGN(Foo); 
}; 

ref from google style sheet

Answer 9

В C++ 11, вы можете явно отключить создание копии по умолчанию и конструктор назначения путем размещения = delete после объявления.

От Wikipedia:

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

То же самое касается классов конечно.