Namespaces
Variants

std::piecewise_construct, std::piecewise_construct_t

De es.cppreference.net
 
 
Biblioteca de utilidades
Soporte del lenguaje
Soporte de tipos (tipos básicos, RTTI)
Macros de prueba de características de la biblioteca (C++20)
Utilidades de programa
Funciones variádicas
Soporte de corrutinas (C++20)
Soporte de contratos (C++26)
Comparación de tres vías
(C++20)
(C++20)(C++20)(C++20)    
(C++20)(C++20)(C++20)

Utilidades generales
Operadores relacionales (obsoleto en C++20)
 
 
Definido en el encabezado <utility>
struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
(1) (desde C++11)
constexpr std::piecewise_construct_t piecewise_construct{};
(2) (desde C++11)
(en línea desde C++17)
1) std::piecewise_construct_t es un tipo de etiqueta de clase vacía usado para desambiguar entre diferentes funciones que toman dos argumentos tuple.
2) La constante std::piecewise_construct es una instancia de (1).

Las sobrecargas que no usan std::piecewise_construct_t asumen que cada argumento tuple se convierte en el elemento de un pair. Las sobrecargas que usan std::piecewise_construct_t asumen que cada argumento tuple se usa para construir, por partes, un nuevo objeto de tipo especificado, que se convertirá en el elemento del pair.

Biblioteca estándar

Los siguientes tipos y funciones de la biblioteca estándar lo utilizan como etiqueta de desambiguación:

implementa tupla binaria, es decir, un par de valores
(plantilla de clase)
prepara la lista de argumentos que coincide con la variante de construcción uses-allocator requerida por el tipo dado
(plantilla de función)
una view que consiste en una secuencia generada produciendo repetidamente el mismo valor
(plantilla de clase) (objeto de punto de personalización)

Ejemplo

#include <iostream>
#include <tuple>
#include <utility>
struct Foo
{
    Foo(std::tuple<int, float>)
    {
        std::cout << "Constructed a Foo from a tuple\n";
    }
    Foo(int, float)
    {
        std::cout << "Constructed a Foo from an int and a float\n";
    }
};
int main()
{
    std::tuple<int, float> t(1, 3.14);
    std::cout << "Creating p1...\n";
    std::pair<Foo, Foo> p1(t, t);
    std::cout << "Creating p2...\n";
    std::pair<Foo, Foo> p2(std::piecewise_construct, t, t);
}

Salida:

Creating p1...
Constructed a Foo from a tuple
Constructed a Foo from a tuple
Creating p2...
Constructed a Foo from an int and a float
Constructed a Foo from an int and a float

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2510 C++11 el constructor por defecto no era explícito, lo que podía llevar a ambigüedad hecho explícito

Véase también

construye un nuevo par
(función miembro pública de std::pair<T1,T2> )