std::ranges:: to

1) Konstruiert ein Objekt vom Typ C aus den Elementen von r wie folgt:

a) Wenn C nicht input_range oder std:: convertible_to < ranges:: range_reference_t < R > , ranges:: range_value_t < C >> erfüllt:

1) Konstruieren eines Nicht-View-Objekts als ob Direct-Initialisierung (aber nicht Direct-List-Initialisierung) eines Objekts vom Typ C aus dem Quellbereich std:: forward < R > ( r ) und den restlichen Funktionsargumenten std:: forward < Args > ( args ) ... falls std:: constructible_from < C, R, Args... > true ist.

2) Andernfalls wird ein Nicht-View-Objekt so konstruiert, als ob Direct-Initialisierung (aber keine Direct-List-Initialisierung) eines Objekts vom Typ C mit zusätzlichem Disambiguierungs-Tag std:: from_range , dem Quell-Bereich std:: forward < R > ( r ) und den restlichen Funktionsargumenten std:: forward < Args > ( args ) ... durchgeführt wird, falls std:: constructible_from < C, std:: from_range_t , R, Args... > true ist.

3) Andernfalls wird ein Nicht-View-Objekt so konstruiert, als ob Direct-Initialisierung (aber keine Direct-List-Initialisierung) eines Objekts vom Typ C aus dem Iterator-Sentinel-Paar ( ranges:: begin ( r ) als Iterator und ranges:: end ( r ) als Sentinel, wobei Iterator und Sentinel denselben Typ haben müssen (mit anderen Worten: der Quellbereich muss ein Common Range sein), und die restlichen Funktionsargumente std:: forward < Args > ( args ) ... , wenn alle der folgenden Bedingungen true sind:

• ranges:: common_range < R >
• Falls std:: iterator_traits < ranges:: iterator_t < R >> :: iterator_category gültig ist und einen Typ bezeichnet, der std:: derived_from < std:: input_iterator_tag > erfüllt
• std:: constructible_from < C, ranges:: iterator_t < R > , ranges:: sentinel_t < R > , Args... >

4) Andernfalls wird ein Nicht-View-Range-Objekt so konstruiert, als würde Direct-Initialisierung (aber keine Direct-List-Initialisierung) eines Objekts vom Typ C aus den restlichen Funktionsargumenten std:: forward < Args > ( args ) ... durchgeführt, mit dem folgenden äquivalenten Aufruf nach der Konstruktion:

if constexpr ( ranges:: sized_range < R > && /*reservable-container*/ < C > ) c. reserve ( static_cast < ranges:: range_size_t < C >> ( ranges:: size ( r ) ) ) ; ranges:: for_each ( r, /*container-appender*/ ( c ) ) ;	(bis C++26)
if constexpr ( ranges :: approximately_sized_range < R > && /*reservable-container*/ < C > ) c. reserve ( static_cast < ranges:: range_size_t < C >> ( ranges :: reserve_hint ( r ) ) ) ; ranges:: for_each ( r, /*container-appender*/ ( c ) ) ;	(seit C++26)

Wenn R die Bedingung sized_range (bis C++26) approximately_sized_range (seit C++26) erfüllt und C die Bedingung reservable-container erfüllt, kann das konstruierte Objekt c vom Typ C Speicher mit der anfänglichen Speichergröße ranges:: size ( r ) (bis C++26) ranges :: reserve_hint ( r ) (seit C++26) reservieren, um zusätzliche Allokationen während des Einfügens neuer Elemente zu vermeiden. Jedes Element von r wird an c angehängt.

Die obigen Operationen sind gültig, wenn beide der folgenden Bedingungen true sind:

• std:: constructible_from < C, Args... >
• container-appendable < C, ranges:: range_reference_t < R >>

b) Andernfalls ist der Rückgabeausdruck äquivalent zu:

to < C > ( ranges:: ref_view ( r ) | views:: transform ( [ ] ( auto && elem )
{
return to < ranges:: range_value_t < C >> ( std:: forward < decltype ( elem ) > ( elem ) ) ;
} ) , std:: forward < Args > ( args ) ... )
Was verschachtelte Bereichskonstruktionen innerhalb des Bereichs ermöglicht, falls ranges:: input_range < ranges:: range_reference_t < C >> true ist.

Andernfalls ist das Programm fehlerhaft.

2) Constructs an object of deduced type from the elements of r .

Sei /*input-iterator*/ ein nur zur Darstellung dienender Typ, der LegacyInputIterator erfüllt:

struct /*Eingabe-Iterator*/ { using iterator_category = std:: input_iterator_tag ; using value_type = ranges:: range_value_t < R > ; using difference_type = std:: ptrdiff_t ; using pointer = std:: add_pointer_t < ranges:: range_reference_t < R >> ; using reference = ranges:: range_reference_t < R > ; reference operator * ( ) const ; // nicht definiert pointer operator - > ( ) const ; // nicht definiert /*Eingabe-Iterator*/ & operator ++ ( ) ; // nicht definiert /*Eingabe-Iterator*/ operator ++ ( int ) ; // nicht definiert bool operator == ( const /*Eingabe-Iterator*/ & ) const ; // nicht definiert } ;		( nur zur Darstellung* )

Sei /*DEDUCE-EXPR*/ wie folgt definiert:

• C ( std:: declval < R > ( ) , std:: declval < Args > ( ) ... ) , falls dieser Ausdruck gültig ist.
• Andernfalls, C ( std:: from_range , std:: declval < R > ( ) ,
  std:: declval < Args > ( ) ... ) , falls dieser Ausdruck gültig ist.
• Andernfalls, C ( std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < Args > ( ) ... ) , falls dieser Ausdruck gültig ist.
• Andernfalls ist das Programm fehlerhaft.

The call is equivalent to zu < decltype ( /*DEDUCE-EXPR*/ ) >
( std:: forward < R > ( r ) , std:: forward < Args > ( args ) ... ) .

3,4) Gibt einen perfekten Weiterleitungsaufruf-Wrapper zurück, der ebenfalls ein RangeAdaptorClosureObject ist.

5) Ist true wenn es ranges:: sized_range erfüllt und für Reservierung geeignet ist.

6) Ist true wenn ein Element vom Typ Reference durch einen Memberfunktionsaufruf von emplace_back , push_back , emplace oder insert an Container angehängt werden kann.

7) Gibt ein Funktionsobjekt zurück, bei dem ein Aufruf des zurückgegebenen Funktionsobjekts ausdrucksäquivalent zum Anhängen eines Elements an einen Container ist. Der Rückgabeausdruck ist äquivalent zu:

return [ & c ] < class Reference > ( Reference && ref )
{
if constexpr ( requires { c. emplace_back ( std:: declval < Reference > ( ) ) ; } )
c. emplace_back ( std:: forward < Reference > ( ref ) ) ;
else if constexpr ( requires { c. push_back ( std:: declval < Reference > ( ) ) ; } )
c. push_back ( std:: forward < Reference > ( ref ) ) ;
else if constexpr ( requires { c. emplace ( c. end ( ) ,
std:: declval < Reference > ( ) ) ; } )
c. emplace ( c. end ( ) , std:: forward < Reference > ( ref ) ) ;
else
c. insert ( c. end ( ) , std:: forward < Reference > ( ref ) ) ;
} ;

8) Wird bei der Definition von Containern verwendet, um einen Eingabebereich R zu konstruieren, dessen Bereichsreferenztyp in T konvertierbar sein muss.

1,2) Ein konstruiertes Nicht-Ansichtsobjekt.

3,4) Ein Range-Adaptor-Closure-Objekt nicht spezifizierten Typs mit folgenden Eigenschaften:

auto vec = r | std::ranges::to<std::vector>;   // Fehler
auto vec = r | std::ranges::to<std::vector>(); // OK

#include <boost/container/devector.hpp>
#include <concepts>
#include <initializer_list>
#include <list>
#include <print>
#include <ranges>
#include <regex>
#include <string>
#include <vector>
#ifndef __cpp_lib_format_ranges
#include <format>
#include <sstream>
auto print_aid(const auto& v)
{
    std::ostringstream out;
    out << '[';
    for (int n{}; const auto& e : v)
        out << (n++ ? ", " : "") << e;
    out << ']';
    return out;
}
template<typename T>
struct std::formatter<std::vector<T>, char>
{
    template<class ParseContext>
    constexpr ParseContext::iterator parse(ParseContext& ctx)
    {
        return ctx.begin();
    }
    template<class FmtContext>
    FmtContext::iterator format(auto const& s, FmtContext& ctx) const
    {
        auto out{print_aid(s)};
        return std::ranges::copy(std::move(out).str(), ctx.out()).out;
    }
};
template<typename T>
struct std::formatter<std::list<T>, char>
{
    template<class ParseContext>
    constexpr ParseContext::iterator parse(ParseContext& ctx)
    {
        return ctx.begin();
    }
    template<class FmtContext>
    FmtContext::iterator format(auto const& s, FmtContext& ctx) const
    {
        auto out{print_aid(s)};
        return std::ranges::copy(std::move(out).str(), ctx.out()).out;
    }
};
#endif
int main()
{
    auto vec = std::views::iota(1, 5)
             | std::views::transform([](int v){ return v * 2; })
             | std::ranges::zu<std::vector>();
    static_assert(std::same_as<decltype(vec), std::vector<int>>);
    std::println("{}", vec);
    auto list = vec | std::views::take(3) | std::ranges::zu<std::list<double>>();
    std::println("{}", list);
}
void ctor_demos()
{
    // 1.a.1) Direkte Initialisierung
    {
        char array[]{'a', 'b', '\0', 'c'};
        // Argumententyp ist in den Ergebnistyp konvertierbar:
        auto str_to = std::ranges::zu<std::string>(array);
        // Entspricht
        std::string str(array);
        // Der Ergebnistyp ist kein Eingabebereich:
        auto re_to = std::ranges::zu<std::regex>(array);
        // Entspricht
        std::regex re(array);
    }
    // 1.a.2) from_range Konstruktor
    {
        auto list = {'a', 'b', '\0', 'c'};
        // Argumententyp ist in den Ergebnistyp konvertierbar:
        auto str_to = std::ranges::zu<std::string>(list);
        // Entspricht
        // std::string str(std::from_range, list);
        // Der Ergebnistyp ist kein Eingabebereich:
        [[maybe_unused]]
        auto pair_to = std::ranges::zu<std::pair<std::from_range_t, bool>>(true);
        // Entspricht
        std::pair<std::from_range_t, bool> pair(std::from_range, true);
    }
    // 1.a.3) Iterator-Paar-Konstruktor
    {
        auto list = {'a', 'b', '\0', 'c'};
        // Argumententyp ist in den Ergebnistyp konvertierbar:
        auto devector_to = std::ranges::zu<boost::Container::devector<char>>(list);
        // Entspricht
        boost::Container::devector<char> devector(std::ranges::begin(list),
                                                  std::ranges::end(list));
        // Der Ergebnistyp ist kein Eingabebereich:
        std::regex re;
        auto it_to = std::ranges::zu<std::cregex_iterator>(list, re);
        // Entspricht
        std::cregex_iterator it(std::ranges::begin(list), std::ranges::end(list), re);
    }
}

[2, 4, 6, 8]
[2, 4, 6]