¿Qué son los puntos de secuencia en C++ y qué tienen que ver con el comportamiento indefinido?

El arma secreta del depurador: lo que los programadores de C++ pasan por alto

¿Alguna vez has escrito algo como i = i++ + ++i; y obtuviste resultados diferentes en distintos compiladores? ¿O atrapaste un error extraño que solo se reproducía en el servidor, pero no en tu portátil? Conoce a: undefined behavior (comportamiento indefinido) — uno de los enemigos más traicioneros del desarrollador de C++. Y en el centro de este caos están los puntos de secuencia (sequence points).

En este artículo analizaremos qué son los sequence points, cómo se relacionan con el orden de evaluación en C++, y —lo más importante— cómo no pisar este rastrillo. El material se basa en una pregunta icónica de Stack Overflow que ha acumulado miles de visitas. ¡Allá vamos!

¿Qué son los puntos de secuencia (sequence points)?

Imagina que eres el director de una orquesta. Cada músico (instrucción del procesador) debe entrar en un momento estrictamente definido. Un punto de secuencia es un momento en el tiempo en el que todos los «efectos secundarios» anteriores (cambios en variables, llamadas a funciones) ya están garantizados como completados, y los siguientes aún no han comenzado.

En el estándar C++ 98/03 se usaba el término sequence point. En C++11 se reemplazó por las relaciones más estrictas «sequenced before / sequenced after», pero la esencia sigue siendo la misma: entre dos puntos de secuencia, el compilador tiene todo el derecho de reordenar las operaciones, siempre que no cambie el resultado (según la regla «as-if»).

En pocas palabras: si intentas modificar la misma variable dos veces entre dos puntos de secuencia — obtienes undefined behavior. El compilador puede hacer cualquier cosa: desde un resultado correcto hasta formatear tu disco duro (es broma, pero casi es cierto).

Ejemplos clásicos de puntos de secuencia

\n
• El punto y coma ; — final de una expresión
\n
• La coma , como operador (¡pero no en los argumentos de una función!)
\n
• El final de cada expresión en un for (después de la inicialización, la condición y el paso)
\n
• Los operadores lógicos && y ||
\n
• El operador ternario ?:
\n
• La llamada a una función (antes de que el cuerpo de la función comience a ejecutarse)
\n

¿Cómo generan los puntos de secuencia un comportamiento indefinido?

Aquí tienes un ejemplo clásico que todo desarrollador de C++ debería conocer:

int i = 0;\ni = i++ + ++i;  // ¡UB! Comportamiento indefinido

¿Por qué es UB? Porque entre dos puntos de secuencia (en este caso, entre el inicio y el final de la expresión) la variable i se modifica dos veces:

\n
1. El incremento postfijo i++
\n
2. El incremento prefijo ++i
\n
3. La asignación i = ...
\n

El compilador no sabe en qué orden ejecutar estas operaciones. ¿El resultado? Un compilador dará 2, otro 3, un tercero 0. Y en modo de optimización podría incluso eliminar este código por completo.

Otro caso engañoso: argumentos de función

int foo(int a, int b) { return a + b; }\n\nint x = 5;\nint result = foo(++x, ++x);  // ¡UB!

Aquí la coma entre los argumentos no es un operador coma, sino un separador. ¡No hay un punto de secuencia entre la evaluación de los argumentos ++x! Ambos incrementos se ejecutan «en paralelo» (desde el punto de vista del estándar), y nuevamente obtenemos undefined behavior.

Ejemplos prácticos: cómo se ve el UB en código real

Ejemplo 1: Error no obvio con indexación

int arr[5] = {0, 10, 20, 30, 40};\nint idx = 1;\narr[idx] = idx++;  // ¡UB!

A primera vista todo es simple: queremos escribir 1 en arr[1] y luego incrementar idx. Pero el estándar no garantiza el orden de evaluación del índice idx y la parte derecha idx++. ¿El resultado? Podría escribirse en arr[1], o podría ser en arr[2].

Ejemplo 2: Comp