Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...::make_array(3) C++ Standard Libarystd::experi...::make_array(3)

NAME
       std::experimental::make_array - std::experimental::make_array

Synopsis
	  Defined in header <experimental/array>
	  template< class D = void, class... Types >
	  constexpr  std::array<VT  /*	see  below */,		      (library
       fundamentals TS v2)
	  sizeof...(Types)> make_array(	Types&&... t );

	  Creates a std::array whose size is equal to the number of  arguments
       and whose
	  elements  are	 initialized from the corresponding arguments. Returns
       std::array<VT,
	  sizeof...(Types)>{std::forward<Types>(t)...}.

	  If  D	 is  void,   then   the	  deduced   type   VT	is   std::com-
       mon_type_t<Types...>. Otherwise,
	  it is	D.

	  If  D	 is void and any of std::decay_t<Types>... is a	specialization
       of
	  std::reference_wrapper, the program is ill-formed.

Notes
	  make_array is	removed	in Library Fundamentals	TS v3 because the  de-
       duction guide for
	  std::array and std::to_array have been already in C++20.

Possible implementation
       namespace details {
	   template<class> struct is_ref_wrapper : std::false_type{};
	   template<class  T> struct is_ref_wrapper<std::reference_wrapper<T>>
       : std::true_type{};

	   template<class T>
	   using   not_ref_wrapper   =	 std::negation<is_ref_wrapper<std::de-
       cay_t<T>>>;

	   template<class  D, class...>	struct return_type_helper { using type
       = D; };
	   template<class... Types>
	   struct    return_type_helper<void,	 Types...>     :     std::com-
       mon_type<Types...>
	   {
	       static_assert(std::conjunction_v<not_ref_wrapper<Types>...>,
			     "Types  cannot  contain reference_wrappers	when D
       is void");
	   };

	   template<class D, class... Types>
	   using  return_type  =   std::array<typename	 return_type_helper<D,
       Types...>::type,
					  sizeof...(Types)>; }

       template<class	D  =  void,  class...  Types>  constexpr  details::re-
       turn_type<D, Types...> make_array(Types&&... t) {
	   return {std::forward<Types>(t)...}; }

Example
       // Run this code

	#include <experimental/array>
	#include <iostream>
	#include <type_traits>

	int main()
	{
	    auto arr = std::experimental::make_array(1,	2, 3, 4, 5);
	    bool  is_array_of_5_ints  =	 std::is_same<decltype(arr),  std::ar-
       ray<int,	5>>::value;
	    std::cout << "Returns an array of five ints? ";
	    std::cout << std::boolalpha	<< is_array_of_5_ints << '\n';
	}

Output:
	Returns	an array of five ints? true

See also
	  C++ documentation for
	  std::array deduction guides
	  to_array creates a std::array	object from a built-in array
		   (function template)

http://cppreference.com		  2024.06.10	 std::experi...::make_array(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::make_array&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>

home | help