c++ - performa - Significado de=borrar después de la declaración de función

como borrar memoria de accu-chek active

Question

class my_class
{
    ...
    my_class(my_class const &) = delete;
    ...
};

¿Qué significa = delete en ese contexto?

¿Hay otros "modificadores" (que no sean = 0 y = delete )?

Answer 1

¿Hay otros "modificadores" (que no sean = 0 y = delete )?

Como parece que nadie más respondió a esta pregunta, debo mencionar que también hay =default .

https://docs.microsoft.com/en-us/cpp/cpp/explicitly-defaulted-and-deleted-functions#explicitly-defaulted-functions

Answer 2

1. = 0 significa que una función es virtual pura y no puede crear una instancia de un objeto de esta clase. Necesitas derivar de él e implementar este método.
2. = delete significa que el compilador no generará esos constructores por ti. AFAIK solo está permitido en el constructor de copia y el operador de asignación. Pero no soy demasiado bueno en el próximo estándar.

Answer 3

Eliminar una función es una característica de C ++ 11 :

El lenguaje común de "prohibir la copia" ahora se puede expresar directamente:

class X {
    // ...
    X& operator=(const X&) = delete;  // Disallow copying
    X(const X&) = delete;
};

[...]

El mecanismo de "eliminar" se puede utilizar para cualquier función. Por ejemplo, podemos eliminar una conversión no deseada como esta:

struct Z {
    // ...

    Z(long long);     // can initialize with an long long         
    Z(long) = delete; // but not anything less
};

Answer 4

Este extracto de The C ++ Programming Language [4ta edición] - El libro Bjarne Stroustrup habla sobre el verdadero propósito de usar =delete :

El uso de la copia o movimiento por defecto para una clase en una jerarquía suele ser un desastre : dado solo un puntero a una base, simplemente no sabemos qué miembros tiene la clase derivada (§3.2.2), por lo que no podemos saber cómo copiarlos . Entonces, lo mejor que se puede hacer es eliminar las operaciones de copia y movimiento predeterminadas, es decir, eliminar las definiciones predeterminadas de esas dos operaciones:

class Shape {
public:
  Shape(const Shape&) =delete; // no copy operations
  Shape& operator=(const Shape&) =delete;

  Shape(Shape&&) =delete; // no move operations
  Shape& operator=(Shape&&) =delete;
  ˜Shape();
    // ...
};

Ahora un intento de copiar una Forma será atrapado por el compilador.

El mecanismo =delete es general, es decir, se puede usar para suprimir cualquier operación

Answer 5

Esto es algo nuevo en los estándares de C ++ 0x donde puede eliminar una función heredada.

Answer 6

Los estándares de codificación con los que he trabajado han tenido lo siguiente para la mayoría de las declaraciones de clase.

  //  coding standard: disallow when not used
  T(void)                  = delete; // default ctor    (1)
  ~T(void)                 = delete; // default dtor    (2)
  T(const T&)              = delete; // copy ctor       (3)
  T(const T&&)             = delete; // move ctor       (4)
  T& operator= (const T&)  = delete; // copy assignment (5)
  T& operator= (const T&&) = delete; // move assignment (6)

Si usa alguno de estos 6, simplemente comente la línea correspondiente.

Ejemplo: la clase FizzBus solo requiere dtor, y por lo tanto no use los otros 5.

//  coding standard: disallow when not used
FizzBuzz(void)                         = delete; // default ctor (1)
// ~FizzBuzz(void);                              // dtor         (2)
FizzBuzz(const FizzBuzz&)              = delete; // copy ctor    (3)
FizzBuzz& operator= (const FizzBuzz&)  = delete; // copy assig   (4)
FizzBuzz(const FizzBuzz&&)             = delete; // move ctor    (5)
FizzBuzz& operator= (const FizzBuzz&&) = delete; // move assign  (6)

Aquí solo comentamos 1, e instalamos la implementación en otro lugar (probablemente donde lo sugiere el estándar de codificación). Los otros 5 (de 6) no están permitidos con eliminar.

También puede usar ''= delete'' para no permitir promociones implícitas de valores de diferentes tamaños ... ejemplo

 // disallow implicit promotion''s 
  template <class T> operator T(void)              = delete;
  template <class T> Vuint64& operator=  (const T) = delete;
  template <class T> Vuint64& operator|= (const T) = delete;
  template <class T> Vuint64& operator&= (const T) = delete;

Answer 7

Nuevo estándar C ++ 0x. Por favor, consulte la sección 8.4.3 en el borrador de trabajo N3242

Answer 8

= delete es una característica introducida en C ++ 11. Según per =delete no se permitirá llamar a esa función.

En detalle.

Supongamos en una clase.

Class ABC{
 Int d;
 Public:
  ABC& operator= (const ABC& obj) =delete
  {

  }
};

Al llamar a esta función para la asignación de obj, no se permitirá. El operador de asignación de medios restringirá la copia de un objeto a otro.