/w/cpp/ranges/sized_range
"cpp/ranges/sized range") and ` C ` satisfies  /*reservable-container*/  , the
constructed object ` c ` of type ` C ` is able to reserve storage with the
initial storage size  [ ranges::  size
](http://en.cppreference.com/w/cpp/ranges/size) (  r  )  to prevent additional
allocations during inserting new elements. Each element of ` r ` is appended
to ` c ` . The operations above are valid if both of the conditions below are
true  :

  * [ std::  constructible_from  ](http://en.cppreference.com/w/cpp/concepts/constructible_from) < C, Args...  >
  * /*container-appendable*/  < C, [ ranges::  range_reference_t  ](http://en.cppreference.com/w/cpp/ranges/iterator_t) < R  >>

b)  Otherwise, the return expression is equivalent to:

to  < C  > (  [ ranges::  ref_view  ](http://en.cppreference.com/w/cpp/ranges/ref_view) (  r  )  |  [ views::  transform  ](http://en.cppreference.com/w/cpp/ranges/transform_view) (  [  ]  (  auto  && elem  )    
{  
return  to  < [ ranges::  range_value_t
](http://en.cppreference.com/w/cpp/ranges/iterator_t) < C  >> (  [ std::
forward  ](http://en.cppreference.com/w/cpp/utility/forward) < decltype  (
elem  )  > (  elem  )  )  ;  
}  )  , [ std::  forward  ](http://en.cppreference.com/w/cpp/utility/forward)
< Args  > (  args  )  ...  )  
Which allows nested range constructions within the range if  [ ranges::
input_range  ](http://en.cppreference.com/w/cpp/ranges/input_range) < [
ranges::  range_reference_t
](http://en.cppreference.com/w/cpp/ranges/iterator_t) < C  >> is  true  .

Otherwise, the program is ill-formed.

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

Let  /*input-iterator*/  be an exposition only type that satisfies [
LegacyInputIterator  ](/w/cpp/named_req/InputIterator "cpp/named
req/InputIterator") :

struct  /*input-iterator*/  
{  
using  iterator_category  =  [ std::  input_iterator_tag
](http://en.cppreference.com/w/cpp/iterator/iterator_tags) ;  
using  value_type  =  [ ranges::  range_value_t
](http://en.cppreference.com/w/cpp/ranges/iterator_t) < R  > ;  
using  difference_type  =  [ std::  ptrdiff_t
](http://en.cppreference.com/w/cpp/types/ptrdiff_t) ;  
using  pointer  =  [ std::  add_pointer_t
](http://en.cppreference.com/w/cpp/types/add_pointer) < [ ranges::
range_reference_t  ](http://en.cppreference.com/w/cpp/ranges/iterator_t) < R
>> ;  
using  reference  =  [ ranges::  range_reference_t
](http://en.cppreference.com/w/cpp/ranges/iterator_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  
}  ;  |  |  (  exposition only*  )   
---|---|---  
|  |   
  
Let  /*DEDUCE-EXPR*/  be defined as follows:

  * C  (  [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < R  > (  )  , [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < Args  > (  )  ...  )  , if that expression is valid. 
  * Otherwise,  C  (  [ std::  from_range  ](http://en.cppreference.com/w/cpp/ranges/from_range) , [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < R  > (  )  , [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < Args  > (  )  ...  )  , if that expression is valid. 
  * Otherwise,  C  (  [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < /*input-iterator*/  > (  )  , [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < /*input-iterator*/  > (  )  , [ std::  declval  ](http://en.cppreference.com/w/cpp/utility/declval) < Args  > (  )  ...  )  , if that expression is valid. 
  * Otherwise, the program is ill-formed. 

The call is equivalent to  to  < decltype  (  /*DEDUCE-EXPR*/  )  > (  [ std::
forward  ](http://en.cppreference.com/w/cpp/utility/forward) < R  >