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.