Namespaces
Variants

    std::piecewise_construct, std::piecewise_construct_t

    Von de.cppreference.net
     
    C++
     
    Dienstprogramm-Bibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programm-Dienstprogramme
    Variate Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::pair
     
    Definiert in Header <utility> 
    struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
    		(1) (seit C++11) 
    constexpr std::piecewise_construct_t piecewise_construct{};
    		(2) (seit C++11)
    (inline seit C++17)
    1) std::piecewise_construct_t ist ein leerer Klassentag-Typ, der zur Unterscheidung zwischen verschiedenen Funktionen dient, die zwei Tuple-Argumente annehmen.
    2) Die Konstante std::piecewise_construct ist eine Instanz von (1).

    Die Überladungen, die std::piecewise_construct_t nicht verwenden, nehmen an, dass jedes Tuple-Argument ein Element eines pair wird. Die Überladungen, die std::piecewise_construct_t verwenden, nehmen an, dass jedes Tuple-Argument verwendet wird, um ein neues Objekt eines bestimmten Typs stückweise (piecewise) zu konstruieren, das dann das Element des pair wird.

    Standardbibliothek

    Die folgenden Standardbibliothekstypen und -funktionen verwenden es als Unterscheidungsmerkmal:

    		implementiert ein binäres Tupel, d.h. ein Wertepaar
    (Klassen-Template)
    (C++20)
    		bereitet die Argumentliste vor, die dem für den gegebenen Typ erforderlichen Uses-Allocator-Konstruktionsstil entspricht
    (Funktions-Template)
    (C++23)
    		eine view , die aus einer generierten Sequenz besteht, indem wiederholt der gleiche Wert erzeugt wird
    (Klassen-Template) (Customization Point Object)

    Beispiel

    Diesen Code ausführen 
    #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);
}

    Ausgabe: 

    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

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 2510 C++11 der Standardkonstruktor war nicht-explicit, was zu Mehrdeutigkeit führen konnte als explicit deklariert

    Siehe auch

    		Konstruiert neues Paar
    (öffentliche Elementfunktion von std::pair<T1,T2> )