Expresiones de pliegue (desde C++17)
De cppreference.com
Reduce (pliega) un paquete de parámetros sobre un operador binario.
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.
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().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
}
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
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]
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 |