std::ranges:: to

1) 通过以下方式从 r 的元素构造一个类型为 C 的对象：

a) 若 C 不满足 input_range 或 std:: convertible_to < ranges:: range_reference_t < R > , ranges:: range_value_t < C >> 为 true ：

1) 如同以直接初始化（但不包括直接列表初始化）方式，从源范围 std:: forward < R > ( r ) 和其余函数实参 std:: forward < Args > ( args ) ... 构造一个非视图对象，当且仅当 std:: constructible_from < C, R, Args... > 为 true 。

2) 否则，如同使用附加消歧标签 std:: from_range 、源范围 std:: forward < R > ( r ) 及其他函数参数 std:: forward < Args > ( args ) ... 对类型 C 的对象进行 直接初始化 （但不包括直接列表初始化）的方式构造非视图对象，前提是 std:: constructible_from < C, std:: from_range_t , R, Args... > 为 true 。

3) 否则，如同使用迭代器-哨位对（以 ranges:: begin ( r ) 作为迭代器、 ranges:: end ( r ) 作为哨位，其中迭代器与哨位具有相同类型。换言之，源范围必须是公共范围）以及其余函数参数 std:: forward < Args > ( args ) ... 来 直接初始化 （但不包括直接列表初始化）类型 C 的对象那样构造非视图对象，当以下所有条件均为 true 时：

• ranges:: common_range < R >
• 若 std:: iterator_traits < ranges:: iterator_t < R >> :: iterator_category 有效且表示满足 std:: derived_from < std:: input_iterator_tag > 的类型
• std:: constructible_from < C, ranges:: iterator_t < R > , ranges:: sentinel_t < R > , Args... >

4) 否则，如同通过函数剩余参数 std:: forward < Args > ( args ) ... 对类型 C 的对象进行 直接初始化 （但不包括直接列表初始化）那样构造一个非视图范围对象，并在构造后执行以下等效调用：

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 ) ) ;	(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 ) ) ;	(C++26 起)

若 R 满足 sized_range (C++26 前) approximately_sized_range (C++26 起) 且 C 满足 reservable-container ，则类型 C 的构造对象 c 能够以初始存储大小 ranges:: size ( r ) (C++26 前) ranges :: reserve_hint ( r ) (C++26 起) 预留存储空间，以避免在插入新元素时进行额外分配。 r 的每个元素会被追加到 c 中。

当以下两个条件均为 true 时，上述操作有效：

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

b) 否则，返回表达式等价于：

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 ) ... )
这允许在范围内部进行嵌套范围构造，当 ranges:: input_range < ranges:: range_reference_t < C >> 为 true 时。

否则，程序非良构。

2) 从 r 的元素构造推导类型的对象。

令 /*input-iterator*/ 为满足 LegacyInputIterator 的说明专用类型：

struct /*input-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 ; // not defined pointer operator - > ( ) const ; // not defined /*input-iterator*/ & operator ++ ( ) ; // not defined /*input-iterator*/ operator ++ ( int ) ; // not defined bool operator == ( const /*input-iterator*/ & ) const ; // not defined } ;		( 说明专用* )

令 /*DEDUCE-EXPR*/ 按如下方式定义：

• C ( std:: declval < R > ( ) , std:: declval < Args > ( ) ... ) ，若该表达式合法。
• 否则， C ( std:: from_range , std:: declval < R > ( ) ,
  std:: declval < Args > ( ) ... ) ，若该表达式合法。
• 否则， C ( std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < /*input-iterator*/ > ( ) ,
  std:: declval < Args > ( ) ... ) ，若该表达式合法。
• 否则，程序非良构。

该调用等价于 to < decltype ( /*DEDUCE-EXPR*/ ) >
( std:: forward < R > ( r ) , std:: forward < Args > ( args ) ... ) 。

3,4) 返回一个完美转发调用包装器，该包装器同时也是一个 RangeAdaptorClosureObject 。

5) 若满足 ranges:: sized_range 且符合可预留条件，则为 true 。

6) 当类型为 true 时，表示可以通过成员函数调用 emplace_back 、 push_back 、 emplace 或 insert 将 Reference 类型的元素追加到 Container 中。

7) 返回一个函数对象，对该函数对象的调用在表达式上等价于向容器追加一个元素。返回表达式等价于：

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) 用于容器定义中，用于构造输入范围 R ，其范围引用类型必须可转换为 T 。

1,2) 一个已构造的非视图对象。

3,4) 一个具有以下特性的未指定类型的范围适配器闭包对象：

auto vec = r | std::ranges::to<std::vector>;   // 错误
auto vec = r | std::ranges::to<std::vector>(); // 正确

#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::to<std::vector>();
    static_assert(std::same_as<decltype(vec), std::vector<int>>);
    std::println("{}", vec);
    auto list = vec | std::views::take(3) | std::ranges::to<std::list<double>>();
    std::println("{}", list);
}
void ctor_demos()
{
    // 1.a.1) 直接初始化
    {
        char array[]{'a', 'b', '\0', 'c'};
        // 参数类型可转换为结果值类型：
        auto str_to = std::ranges::to<std::string>(array);
        // 等价于
        std::string str(array);
        // 结果类型不是输入范围：
        auto re_to = std::ranges::to<std::regex>(array)<span class="