¿Puedo evitar la asignación de objetos?

Question

quiero asegurar que el siguiente tipo de llamada es ilegal:

MyClass me; 
MyClass you; 
me = you; // how to make this illegal? 

¿Es posible?

Answer 1

declarar el operador de asignación privada:

class A { 
    private: 
    void operator=(const A&); 
    ... 
}; 

pero no proporcionan una implementación - obtendrá un error de compilación o de tiempo de enlace si intenta realizar una asignación a A.

Prefiero usar una macro para hacer esto. Esto también impide la copia, haciendo que el constructor de copia privada también:

#define CANNOT_COPY(class) \ 
    private:     \ 
    class(const class&); \ 
    void operator=(const class &) \ 

A continuación, puedo decir cosas como:

class A { 
    CANNOT_COPY(A); 
    ... 
}; 

que es fácil de leer y fácil de buscar.

Answer 2

declarar el operador de asignación como private.

Answer 3

Sí - defina un operador de asignación privada (operator=) o derive de la práctica clase boost::noncopyable.

Answer 4

Usar const.

MyClass const me; 
MyClass you; 
me = you; // compilation error 

Answer 5

Utilizo para derivar mis clases no copiables de una clase común no copiable. Si no se utiliza impulso, por lo general utilice este atajo:

class NonCopyable 
{ 
protected: 
    /** 
    * Protected default constructor 
    */ 
    NonCopyable() {} 

    /** 
    * Protected destructor 
    */ 
    ~NonCopyable() {} 

private: 

    /** 
    * Private copy constructor 
    */ 
    NonCopyable(const NonCopyable&); 

    /** 
    * Private assignment operator 
    */ 
    const NonCopyable& operator=(const NonCopyable&); 
}; 

Tenga en cuenta que ni el constructor de copia, ni los operadores de asignación tienen una implementación.

Answer 6

Las demás respuestas aquí son todas correctas. Sin embargo, es importante tener en cuenta que solo está prohibiendo el código específico que mencionó. Alguien puede seguir y hacer un duplicado de tu clase mediante el uso de memcpy u otras estrategias.

Answer 7

A partir de C++ 11, mi entendimiento es que la solución preferida es utilizar the '= delete' construct:

class MyClass { 
    MyClass (const MyClass&) = delete; // Disable copy constructor 
    MyClass& operator=(const MyClass&) = delete; // Disable assignment 
    ... 
} 

Entonces

MyClass me; 
MyClass you; 
me = you; // won't compile