¿Cuándo se vuelve inaccesible el operador de asignación predeterminado de C++?

Question

Si defino un operador de asignación propia, que tiene una firma diferente que el operador de asignación por defecto normalmente generada:

struct B; 
struct A { 
void operator = (const B& b) { 
    // assign something 
} 
}; 

hace el operador de asignación por defecto, en este caso operator = (A&) (o similar, corrígeme si mal) convertirse en indefinido/inaccesible?

AFAIK esto es cierto para el constructor predeterminado, que no existe, si definimos algún otro constructor. Pero realmente no estoy seguro si este es el caso para los otros valores predeterminados "mágicos".

La razón por la que pregunto: quiero evitar que el constructor de copia predeterminado se llame accidentalmente mediante una conversión de tipo implícita. Si no existe, nunca podría suceder.

Answer 1

No. 12,8/9 dice que el operador de asignación para la clase X no debe ser estática, no molde con un parámetro de tipo X, X &, X const &, X volátil & o X const volátil &. Y hay una nota que enfatiza que la instanciación de una plantilla no suprime la declaración implícita.

Answer 2

Dado que A& operator=(B&) no tiene la firma de A& operator=(const A&), esto no le sirve de nada al operador de asignación sintetizado.

Eche un vistazo a this snippet at codepad.org - por lo que un ejemplo cuenta como prueba.

Prueba de conducción Comeau con él también muestra que A& operator=(const A&) es sintetizado.

Answer 3

AFAIK esto es cierto para el constructor predeterminado, que no existe, si definimos algún otro constructor. Pero realmente no estoy seguro si este es el caso para los otros valores predeterminados "mágicos".

El valor predeterminado constructor de copia no se verán afectados por la prestación de otro constructor ...

La razón que pido: Quiero evitar que el constructor de copia por defecto se llama accidentalmente a través de un tipo implícito conversión. Si no existe, nunca podría suceder.

... u operador de asignación. Por ejemplo:

class A { 
      private: 
      A& operator= (const A& a); // private here means: forbidden operator 
      public: 
      A(int i) {} 
    }; 

    int main() { 
      A a(2); 
      A b(a);   // copy constructor syntax 1 
      A c = a;  // copy constructor syntax 2 
      // Forbidden: A d; 
      // Forbidden: c = a; 
    } 

Para deshabilitar el constructor de copia predeterminado, declararlo (no es necesario implementar, por supuesto) como privado. Con respecto a su caso de uso, es posible que también desee echarle un vistazo a la palabra clave "explicit" para suprimir la conversión de tipo automático.