Saltar a contenido

Última actualización：2026-10-12

constexpr y la expresión coma en C++20

C++20那些事: constexpr y comma expr

C++20 introdujo varias características nuevas que refuerzan aún más las capacidades en tiempo de compilación y la seguridad del código. Este artículo explora a fondo dos cambios importantes: el manejo de excepciones en funciones constexpr y la deprecación del operador coma en el operador de subíndice.

Nota: versión para impacientes, los ejemplos de código y la documentación relacionada de esta sección ya están actualizados en el Planeta; si te interesa, únete.

1. El cambio que permite try-catch en funciones constexpr

Antes de C++20, no se podían usar bloques try-catch en funciones constexpr, limitación que impedía el procesamiento en tiempo de compilación de algunos contenedores de la biblioteca estándar como std::array. C++20 mejoró esto: permite usar bloques try-catch en funciones constexpr e ignora estas estructuras de manejo de excepciones en contextos de expresión constante. Si durante la evaluación de una expresión constante se lanza una excepción, el compilador da un error.

El objetivo principal de este cambio es que los contenedores de la biblioteca estándar, como std::array, puedan soportar constexpr, y sentar las bases para dar soporte en el futuro a más manejo de excepciones en tiempo de compilación.

Ejemplo:

constexpr int SafeDivide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero!");  // 当除数为0时抛出异常
    }
    return a / b;
}

constexpr int ComputeQuotient(int x) {
    try {
        return SafeDivide(100, x);  // 尝试除法运算
    } catch (const std::runtime_error&) {
        return -1;  // 捕获除零异常并返回 -1
    }
}

El código anterior no compilaba antes de C++20; ¿cuál es el comportamiento en C++20? Puedes intentar adivinar cuál de estos dos resultados se cumple:

static_assert(ComputeQuotient(25) == 4); 
static_assert(ComputeQuotient(0) == -1);

2. Deprecación del operador coma en el operador de subíndice

Otro cambio de C++20 es la deprecación del uso del operador coma dentro del operador de subíndice. En versiones antiguas de C++, en la expresión array[x, y] el operador coma hacía que y se pasara como subíndice del array o contenedor, mientras que x se ignoraba. Sin embargo, este uso hacía el código difícil de entender y estorbaba la futura implementación de arrays multidimensionales. Por eso, desde C++20 el operador coma en el operador de subíndice queda deprecado, salvo que se usen paréntesis para especificar la precedencia explícitamente, como en array[(x, y)].

Código de ejemplo:

// arr[i, j] = 10;  // C++17 中合法，C++20 中弃用
arr[(i, j)] = 10;  // 使用括号以明确逗号的优先级

En este ejemplo, arr[(i, j)] usa paréntesis para dejar clara la precedencia del operador coma, garantizando que j se pase como subíndice del array. En C++17, arr[i, j] estaba permitido, pero en C++20 este uso dispara una advertencia de deprecación. De esta forma se garantiza que el comportamiento del código sea consistente y conforme al nuevo estándar de C++20.

Si se usa el operador coma, el compilador advertirá:

common.cc:9:10: warning: top-level comma expression in array subscript is deprecated [-Wcomma-subscript]
    9 |     arr[i, j] = 10;  // C++17 中合法，C++20 中弃用
      |          ^

Resumen

Los cambios de C++20, en particular el soporte de manejo de excepciones en funciones constexpr y la deprecación del operador coma en el operador de subíndice, buscan mejorar las capacidades en tiempo de compilación y la legibilidad del código. Si tu código depende de estas características antiguas, conviene ajustarlo cuanto antes para adaptarlo al nuevo estándar de C++20.

Temas relacionados

Comentarios