Expresiones de pliegue (desde C++17)
De cppreference.com
Reduce (pliega) un paquete de parámetros sobre un operador binario.
Contenido |
[editar] Sintaxis
( paquete op … )
|
(1) | ||||||||
( ... op paquete )
|
(2) | ||||||||
( paquete op ... op init )
|
(3) | ||||||||
( init op ... op paquete )
|
(4) | ||||||||
1) Pliegue unario derecho.
2) Pliegue unario izquierdo.
3) Pliegue binario derecho.
4) Pliegue binario izquierdo.
| op | - | Cualquiera de los siguientes 32 operadores binarios: + - * / % ^ & | = < > << >> += -= *= /= %= ^= &= |= <<= >>= == != <= >= && || , .* ->*. En un pliegue binario, ambos operadores deben ser los mismos. |
| paquete | - | Una expresión que contiene un paquete de parámetros sin expandir y no contiene un operador con precedencia más baja que una conversión al nivel superior (formalmente, una expresión-de-conversión). |
| init | - | Una expresión que no contiene un paquete de parámetros sin expandir y no contiene un operador con precedencia más baja que una conversión al nivel superior (formalmente, una expresión-de-conversión). |
Observe que los paréntesis de apertura y clausura son una parte requerida de la expresión de pliegue.
[editar] Explicación
La instanciación de una expresión de pliegue expande a la expresión e de la siguiente manera:
1) Pliegue unario derecho
(E op ...) se vuelve (E1 op (... op (EN-1 op EN)))2) Pliegue unario izquierdo
(... op E) se vuelve {(((E1 op E2) op ...) op EN)3) Pliegue binario derecho
(E op ... op I) se vuelve (E1 op (... op (EN−1 op (EN op I))))4) Pliegue binario izquierdo
(I op ... op E) se vuelve ((((I op E1) op E2) op ...) op EN)(donde N es el número de elementos en la expansión de paquete).
Por ejemplo,
template<typename... Args> bool todos(Args... args) { return (... && args); } bool b = todos(true, true, true, false); // dentro de todos(), el pliegue unario izquierdo se expande como // return ((true && true) && true) && false; // b es false
Cuando un pliegue unario se usa con una expansión de paquete de longitud cero, solo se permiten los siguientes operadores:
1) AND lógico (&&). El valor para el paquete vacío es true.
2) OR lógico (||). El valor para el paquete vacío es false.
3) El operador coma (,). El valor para el paquete vacío es void().
[editar] Nota
Si la expresión usada como init o como paquete tiene un operador con precedencia menor que una conversión al nivel superior, deben usarse paréntesis:
template<typename ...Args> int sum(Args&&... args) { // return (args + ... + 1 * 2); // ERROR: operador con precedencia menor que conversión return (args + ... + (1 * 2)); // de acuerdo }
[editar] Ejemplo
Ejecuta este código
#include <concepts> #include <iostream> #include <vector> #include <climits> #include <cstdint> #include <type_traits> #include <utility> template<typename ...Args> void impresor(Args&&... args) { (std::cout << ... << args) << '\n'; } template<typename T, typename... Args> void anexar_vec(std::vector<T>& v, Args&&... args) { static_assert((std::is_constructible_v<T, Args&&> && ...)); (v.push_back(std::forward<Args>(args)), ...); } template<class T, std::size_t... dummy_pack> constexpr T bswap_impl(T i, std::index_sequence<dummy_pack...>) { T low_byte_mask = (unsigned char)-1; T ret{}; ([&] { (void)dummy_pack; ret <<= CHAR_BIT; ret |= i & low_byte_mask; i >>= CHAR_BIT; }(), ...); return ret; } constexpr auto bswap(std::unsigned_integral auto i) { return bswap_impl(i, std::make_index_sequence<sizeof(i)>{}); } int main() { impresor(1, 2, 3, "abc"); std::vector<int> v; anexar_vec(v, 6, 2, 45, 12); anexar_vec(v, 1, 2, 9); for (int i : v) std::cout << i << ' '; static_assert(bswap<std::uint16_t>(0x1234u)==0x3412u); static_assert(bswap<std::uint64_t>(0x0123456789abcdefULL)==0xefcdab8967452301ULL); }
Salida:
123abc 6 2 45 12 1 2 9
[editar] Referencias
- El estándar C++23 (ISO/IEC 14882:2023):
- 7.5.6 Fold expressions [expr.prim.fold]
- El estándar C++20 (ISO/IEC 14882:2020):
- 7.5.6 Fold expressions [expr.prim.fold]
- El estándar C++17 (ISO/IEC 14882:2017):
- 8.1.6 Fold expressions [expr.prim.fold]
[editar] Reporte de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| CWG 2611 | C++17 | los resultados de expansión de las expresiones de pliegue no se encerraban entre paréntesis |
encerrado entre paréntesis |
