¿Cuáles son todos los comportamientos indefinidos comunes que un programador de C ++ debe conocer? [cerrado]

¿Cuáles son todos los comportamientos indefinidos comunes que un programador de C ++ debe conocer?

Diga, como:

a[i] = i++;

Puntero

• Desreferenciar un NULLpuntero
• Desreferenciar un puntero devuelto por una "nueva" asignación de tamaño cero
• Usar punteros a objetos cuya vida útil ha finalizado (por ejemplo, apilar objetos asignados u objetos eliminados)
• Desreferenciar un puntero que aún no se ha inicializado definitivamente
• Realización de aritmética de puntero que produce un resultado fuera de los límites (arriba o abajo) de una matriz.
• Desreferenciar el puntero en una ubicación más allá del final de una matriz.
• Convertir punteros a objetos de tipos incompatibles
• Utilizando memcpypara copiar buffers superpuestos .

El buffer se desborda

• Lectura o escritura en un objeto o matriz en un desplazamiento que es negativo o superior al tamaño de ese objeto (desbordamiento de pila / montón)

Desbordamientos de enteros

• Desbordamiento de entero firmado
• Evaluar una expresión que no está matemáticamente definida
• Valores de desplazamiento a la izquierda en una cantidad negativa (los desplazamientos a la derecha en cantidades negativas están definidos por la implementación)
• Cambio de valores en una cantidad mayor o igual al número de bits en el número (por ejemplo, int64_t i = 1; i <<= 72no está definido)

Tipos, Reparto y Const

• Convertir un valor numérico en un valor que no puede ser representado por el tipo de destino (ya sea directamente o mediante static_cast)
• Usar una variable automática antes de que se haya asignado definitivamente (por ejemplo, int i; i++; cout << i;)
• Usar el valor de cualquier objeto de tipo que no sea volatileosig_atomic_t al recibir una señal
• Intentar modificar un literal de cadena o cualquier otro objeto constante durante su vida útil
• Concatenando un literal de cadena estrecho con ancho durante el preprocesamiento

Función y plantilla

• No devolver un valor de una función de retorno de valor (directamente o saliendo de un bloque try)
• Múltiples definiciones diferentes para la misma entidad (clase, plantilla, enumeración, función en línea, función miembro estática, etc.)
• Infinita recursividad en la creación de instancias de plantillas
• Llamar a una función usando diferentes parámetros o enlaces a los parámetros y enlaces que la función se define como usando.

OOP

• Destrucciones en cascada de objetos con duración de almacenamiento estático
• El resultado de asignar objetos parcialmente superpuestos
• Reingresar recursivamente una función durante la inicialización de sus objetos estáticos
• Realizar llamadas a funciones virtuales a funciones virtuales puras de un objeto desde su constructor o destructor
• Refiriéndose a miembros no estáticos de objetos que no han sido construidos o ya han sido destruidos

Archivo fuente y preprocesamiento

• Un archivo fuente no vacío que no termina con una nueva línea o termina con una barra diagonal inversa (antes de C ++ 11)
• Una barra diagonal inversa seguida de un carácter que no forma parte de los códigos de escape especificados en un carácter o cadena constante (esto se define en la implementación en C ++ 11).
• Exceder los límites de implementación (número de bloques anidados, número de funciones en un programa, espacio de pila disponible ...)
• Valores numéricos del preprocesador que no se pueden representar mediante un long int
• Directiva de preprocesamiento en el lado izquierdo de una definición de macro similar a una función
• Generando dinámicamente el token definido en una #ifexpresión

Para ser clasificado

• Llamar a la salida durante la destrucción de un programa con duración de almacenamiento estático

El orden en que se evalúan los parámetros de la función es el comportamiento no especificado . (Esto no hará que su programa se bloquee, explote u ordene pizza ... a diferencia del comportamiento indefinido ).

El único requisito es que todos los parámetros deben evaluarse completamente antes de llamar a la función.

Esta:

// The simple obvious one.
callFunc(getA(),getB());

Puede ser equivalente a esto:

int a = getA();
int b = getB();
callFunc(a,b);

O esto:

int b = getB();
int a = getA();
callFunc(a,b);

Puede ser cualquiera; depende del compilador. El resultado puede importar, dependiendo de los efectos secundarios.

El compilador es libre de reordenar las partes de evaluación de una expresión (suponiendo que el significado no haya cambiado).

De la pregunta original:

a[i] = i++;

// This expression has three parts:
(a) a[i]
(b) i++
(c) Assign (b) to (a)

// (c) is guaranteed to happen after (a) and (b)
// But (a) and (b) can be done in either order.
// See n2521 Section 5.17
// (b) increments i but returns the original value.
// See n2521 Section 5.2.6
// Thus this expression can be written as:

int rhs  = i++;
int lhs& = a[i];
lhs = rhs;

// or
int lhs& = a[i];
int rhs  = i++;
lhs = rhs;

Doble comprobación de bloqueo. Y un error fácil de cometer.

A* a = new A("plop");

// Looks simple enough.
// But this can be split into three parts.
(a) allocate Memory
(b) Call constructor
(c) Assign value to 'a'

// No problem here:
// The compiler is allowed to do this:
(a) allocate Memory
(c) Assign value to 'a'
(b) Call constructor.
// This is because the whole thing is between two sequence points.

// So what is the big deal.
// Simple Double checked lock. (I know there are many other problems with this).
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        a = new A("Plop");  // (Point A).
    }
}
a->doStuff();

// Think of this situation.
// Thread 1: Reaches point A. Executes (a)(c)
// Thread 1: Is about to do (b) and gets unscheduled.
// Thread 2: Reaches point B. It can now skip the if block
//           Remember (c) has been done thus 'a' is not NULL.
//           But the memory has not been initialized.
//           Thread 2 now executes doStuff() on an uninitialized variable.

// The solution to this problem is to move the assignment of 'a'
// To the other side of the sequence point.
if (a == null) // (Point B)
{
    Lock   lock(mutex);
    if (a == null)
    {
        A* tmp = new A("Plop");  // (Point A).
        a = tmp;
    }
}
a->doStuff();

// Of course there are still other problems because of C++ support for
// threads. But hopefully these are addresses in the next standard.

Mi favorita es "La recursión infinita en la creación de instancias de plantillas" porque creo que es la única en la que el comportamiento indefinido ocurre en el momento de la compilación.

Asignación a una constante después de despojar constusando const_cast<>:

const int i = 10; 
int *p =  const_cast<int*>( &i );
*p = 1234; //Undefined

Además del comportamiento indefinido , también existe el comportamiento igualmente desagradable definido por la implementación .

El comportamiento indefinido ocurre cuando un programa hace algo cuyo resultado no está especificado por el estándar.

El comportamiento definido por la implementación es una acción de un programa cuyo resultado no está definido por el estándar, pero que la implementación debe documentar. Un ejemplo es "Literales de caracteres multibyte", de la pregunta de desbordamiento de pila ¿Hay un compilador de C que no puede compilar esto? .

El comportamiento definido por la implementación solo lo muerde cuando comienza a portar (¡pero actualizar a una nueva versión del compilador también es portar!)

Las variables solo pueden actualizarse una vez en una expresión (técnicamente una vez entre puntos de secuencia).

int i =1;
i = ++i;

// Undefined. Assignment to 'i' twice in the same expression.

Una comprensión básica de los diversos límites ambientales. La lista completa se encuentra en la sección 5.2.4.1 de la especificación C. Aquí hay algunos;

• 127 parámetros en una definición de función
• 127 argumentos en una llamada de función
• 127 parámetros en una macro definición
• 127 argumentos en una macro invocación
• 4095 caracteres en una línea de origen lógica
• 4095 caracteres en un literal de cadena de caracteres o literal de cadena ancha (después de la concatenación)
• 65535 bytes en un objeto (solo en un entorno alojado)
• 15 niveles de envejecimiento para # archivos incluidos
• 1023 etiquetas de caso para una declaración de cambio (excluyendo aquellas para cualquier declaración de cambio anidado)

En realidad, me sorprendió un poco el límite de 1023 etiquetas de caso para una declaración de cambio, puedo prever que se supere con bastante facilidad para el código / lex / analizador generado.

Si se exceden estos límites, tiene un comportamiento indefinido (fallas, fallas de seguridad, etc.).

Correcto, sé que esto es de la especificación C, pero C ++ comparte estos soportes básicos.

Utilizando memcpypara copiar entre regiones de memoria superpuestas. Por ejemplo:

char a[256] = {};
memcpy(a, a, sizeof(a));

El comportamiento no está definido de acuerdo con el Estándar C, que está incluido en el Estándar C ++ 03.

7.21.2.1 La función memcpy

Sinopsis

1 / #include void * memcpy (void * restrict s1, const void * restrict s2, size_t n);

Descripción

2 / La función memcpy copia n caracteres del objeto señalado por s2 en el objeto señalado por s1. Si la copia se lleva a cabo entre objetos que se superponen, el comportamiento es indefinido. Devuelve 3 La función memcpy devuelve el valor de s1.

7.21.2.2 La función memmove

Sinopsis

1 #include void * memmove (void * s1, const void * s2, size_t n);

Descripción

2 La función memmove copia n caracteres del objeto señalado por s2 en el objeto señalado por s1. La copia se realiza como si los n caracteres del objeto señalado por s2 se copiaran primero en una matriz temporal de n caracteres que no se superponen a los objetos señalados por s1 y s2, y luego los n caracteres de la matriz temporal se copian en El objeto señalado por s1. Devoluciones

3 La función memmove devuelve el valor de s1.

El único tipo para el que C ++ garantiza un tamaño es char. Y el tamaño es 1. El tamaño de todos los demás tipos depende de la plataforma.

Los objetos de nivel de espacio de nombres en unidades de compilación diferentes nunca deberían depender unos de otros para la inicialización, porque su orden de inicialización no está definido.