c++ - smart - ¿Por qué eliminar explícitamente el constructor?

smart contracts ethereum

Question

¿Cuándo / por qué querría eliminar explícitamente mi constructor? Suponiendo que la razón es para evitar su uso, ¿por qué no solo hacerla private ?

class Foo
{ 
  public: 
    Foo() = delete; 
};

¡Gracias!

Answer 1

Me reuní con los indicadores predeterminados declarados como ''eliminados'' en el código fuente de LLVM (en AlignOf.h por ejemplo). Las plantillas de clase asociadas usualmente están en un espacio de nombres especial llamado ''llvm :: detail''. Creo que todo el propósito fue que consideraban esa clase solo como una clase auxiliar. Nunca tuvieron la intención de instanciarlos; solo para usarlas dentro del contexto de otras plantillas de clase con algunos trucos de metaprogramación que se ejecutan en tiempo de compilación.

P.ej. existe esta plantilla de clase AlignmentCalcImpl que se usa solo dentro de otra plantilla de clase llamada AlignOf como un parámetro para el operador sizeof (.). Esa expresión puede ser evaluada en tiempo de compilación; y no hay necesidad de crear una instancia de la plantilla -> entonces, ¿por qué no declarar la eliminación de ctor predeterminada para expresar esta intención?

Pero es solo mi suposición.

Answer 2

Qué tal si:

//deleted constructor
class Foo
{ 
  public: 
    Foo() = delete;     
  public:
    static void foo();
};

void Foo::foo()
{
   Foo f;    //illegal
}

versus

//private constructor
class Foo
{ 
  private: 
    Foo() {}     
  public:
    static void foo();
};

void Foo::foo()
{
   Foo f;    //legal
}

Son básicamente cosas diferentes. private le dice que solo los miembros de la clase pueden llamar a ese método o acceder a esa variable (o amigos, por supuesto). En este caso, es legal que un método static de esa clase (o cualquier otro miembro) llame a un constructor private de una clase. Esto no es válido para los constructores eliminados.

Muestra here .

Answer 3

¿Por qué eliminar explícitamente el constructor?

Otra razón:
Uso delete cuando quiero asegurar que se llame a una clase con un inicializador. Considero que es una forma muy elegante de lograr esto sin controles de tiempo de ejecución.

El compilador de C ++ hace esta comprobación por ti.

class Foo
{
   public:
       Foo() = delete;
       Foo(int bar) : m_bar(bar) {};
   private:
       int m_bar;
}

Este código, muy simplificado , asegura que no hay una instanciación como esta: Foo foo;