std::ranges:: to

1) Construit un objet de type C à partir des éléments de r de la manière suivante :

a) Si C ne satisfait pas input_range ou std:: convertible_to < ranges:: range_reference_t < R > , ranges:: range_value_t < C >> est true :

1) Construire un objet non-vue comme si on initialisait directement (mais pas par initialisation de liste directe) un objet de type C à partir de la plage source std:: forward < R > ( r ) et des autres arguments fonctionnels std:: forward < Args > ( args ) ... si std:: constructible_from < C, R, Args... > est true .

2) Sinon, construction d'un objet non-vue comme si on initialisait directement (mais pas par initialisation de liste directe) un objet de type C à partir du tag de désambiguïsation supplémentaire std:: from_range , la plage source std:: forward < R > ( r ) et les autres arguments fonctionnels std:: forward < Args > ( args ) ... si std:: constructible_from < C, std:: from_range_t , R, Args... > est true .

3) Sinon, construction d'un objet non-vue comme si on initialisait directement (mais pas par initialisation de liste directe) un objet de type C à partir de la paire itérateur-sentinelle ( ranges:: begin ( r ) comme itérateur et ranges:: end ( r ) comme sentinelle, où l'itérateur et la sentinelle ont le même type. En d'autres termes, la plage source doit être une plage commune), et les autres arguments de fonction std:: forward < Args > ( args ) ... si toutes les conditions suivantes sont true :

• ranges:: common_range < R >
• Si std:: iterator_traits < ranges:: iterator_t < R >> :: iterator_category est valide et désigne un type qui satisfait std:: derived_from < std:: input_iterator_tag >
• std:: constructible_from < C, ranges:: iterator_t < R > , ranges:: sentinel_t < R > , Args... >

4) Sinon, construction d'un objet de plage non-vue comme si on initialisait directement (mais pas par initialisation de liste directe) un objet de type C à partir des autres arguments de la fonction std:: forward < Args > ( args ) ... avec l'appel équivalent suivant après la construction :

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 ) ) ;	(jusqu'en 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 ) ) ;	(depuis C++26)

Si R satisfait sized_range (jusqu'en C++26) approximately_sized_range (depuis C++26) et C satisfait reservable-container , l'objet construit c de type C peut réserver du stockage avec la taille de stockage initiale ranges:: size ( r ) (jusqu'en C++26) ranges :: reserve_hint ( r ) (depuis C++26) pour éviter des allocations supplémentaires lors de l'insertion de nouveaux éléments. Chaque élément de r est ajouté à c .

Les opérations ci-dessus sont valides si les deux conditions suivantes sont true :

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

b) Sinon, l'expression de retour est équivalente à :

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 ) ... )
Ce qui permet les constructions de plages imbriquées à l'intérieur de la plage si ranges:: input_range < ranges:: range_reference_t < C >> est true .

Sinon, le programme est mal formé.

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

Soit /*input-iterator*/ un type d'exposition uniquement qui satisfait LegacyInputIterator :

struct /*itérateur-entrée*/ { 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 ; // non défini pointer operator - > ( ) const ; // non défini /*itérateur-entrée*/ & operator ++ ( ) ; // non défini /*itérateur-entrée*/ operator ++ ( int ) ; // non défini bool operator == ( const /*itérateur-entrée*/ & ) const ; // non défini } ;		( exposition uniquement* )

Soit /*DEDUCE-EXPR*/ défini comme suit :

• C ( std:: declval < R > ( ) , std:: declval < Args > ( ) ... ) , si cette expression est valide.
• Sinon, C ( std:: from_range , std:: declval < R > ( ) ,
  std:: declval < Args > ( ) ... ) , si cette expression est valide.
• Sinon, C ( std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < Args > ( ) ... ) , si cette expression est valide.
• Sinon, le programme est mal formé.

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

3,4) Renvoie un wrapper d'appel à transfert parfait qui est également un RangeAdaptorClosureObject .

5) Est true s'il satisfait ranges:: sized_range et est éligible à être réservable.

6) Est true si un élément de type Reference peut être ajouté à Container via un appel de fonction membre emplace_back , push_back , emplace ou insert .

7) Retourne un objet fonction où un appel à l'objet fonction retourné est expression-équivalent à l'ajout d'un élément à un conteneur. L'expression de retour est équivalente à :

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) Est utilisé dans la définition des conteneurs pour construire une plage d'entrée R dont le type de référence de plage doit être convertible en T .

1,2) Un objet non-vue construit.

3,4) Un objet de fermeture d'adaptateur de plage de type non spécifié, avec les propriétés suivantes :

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

#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::à<std::vector>();
    static_assert(std::same_as<decltype(vec), std::vector<int>>);
    std::println("{}", vec);
    auto list = vec | std::views::take(3) | std::ranges::à<std::list<double>>();
    std::println("{}", list);
}
void ctor_demos()
{
    // 1.a.1) Initialisation directe
    {
        char array[]{'a', 'b', '\0', 'c'};
        // Le type d'argument est convertible en type de valeur de résultat :
        auto str_to = std::ranges::à<std::string>(array);
        // Équivalent à
        std::string str(array);
        // Le type de résultat n'est pas une plage d'entrée :
        auto re_to = std::ranges::à<std::regex>(array);
        // Équivalent à
        std::regex re(array);
    }
    // 1.a.2) constructeur from_range
    {
        auto list = {'a', 'b', '\0', 'c'};
        // Le type d'argument est convertible en type de valeur de résultat :
        auto str_to = std::ranges::à<std::string>(list);
        // Équivalent à
        // std::string str(std::from_range, list);
        // Le type de résultat n'est pas une plage d'entrée :
        [[maybe_unused]]
        auto pair_to = std::ranges::à<std::pair<std::from_range_t, bool>>(true);
        // Équivalent à
        std::pair<std::from_range_t, bool> pair(std::from_range, true);
    }
    // 1.a.3) constructeur avec paire d'itérateurs
    {
        auto list = {'a', 'b', '\0', 'c'};
        // Le type d'argument est convertible en type de valeur de résultat :
        auto devector_to = std::ranges::à<boost::container::devector<char>>(list);
        // Équivalent à
        boost::container::devector<char> devector(std::ranges::begin(list),
                                                  std::ranges::end(list));
        // Le type de résultat n'est pas une plage d'entrée :
        std::regex re;
        auto it_to = std::ranges::à<std::cregex_iterator>(list, re);
        // Équivalent à
        std::cregex_iterator it(std::ranges::begin(list), std::ranges::end(list), re);
    }
}

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