Namespaces
Variants

    std::piecewise_construct, std::piecewise_construct_t

    Von de.cppreference.net
     
    C++
     
    Hilfsbibliothek
    Sprachunterstützung
    Typ-Unterstützung (Basistypen, RTTI)
    Bibliotheks-Feature-Test-Makros (C++20)
    Programmhilfsmittel
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinenunterstützung (C++20)
    Vertragsunterstützung (C++26)
    Drei-Wege-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 Hilfsmittel
    Relationsoperatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Swap und Typ-Operationen
    (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 im 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 Klassen-Tag-Typ, der verwendet wird, um zwischen verschiedenen Funktionen zu unterscheiden, die zwei tuple-Argumente entgegennehmen.
    2) Die Konstante std::piecewise_construct ist eine Instanz von (1).

    Die Überladungen, die std::piecewise_construct_t nicht verwenden, nehmen an, dass jedes Tupel-Argument zum Element eines Paares wird. Die Überladungen, die std::piecewise_construct_t verwenden, nehmen an, dass jedes Tupel-Argument verwendet wird, um stückweise (piecewise) ein neues Objekt des angegebenen Typs zu konstruieren, das zum Element des Paares 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 derselbe Wert erzeugt wird
    (Klassen-Template) (Anpassungspunkt-Objekt)

    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 Member-Funktion von std::pair<T1,T2> )