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

FreeBSD Manual Pages

  
 
  

home | help 
std::uninitialized_fill(3)    C++ Standard Libary   std::uninitialized_fill(3)

NAME
       std::uninitialized_fill - std::uninitialized_fill

Synopsis
	  Defined in header <memory>
	  template< class ForwardIt, class T >
	  void	uninitialized_fill(  ForwardIt first, ForwardIt	last, const T&
       (1)
	  value	);
	  template< class ExecutionPolicy, class ForwardIt, class T >

	  void	     uninitialized_fill(       ExecutionPolicy&&       policy,
       (2) (since C++17)

				   ForwardIt first, ForwardIt last, const T&
	  value	);

	  1)  Copies  the given	value to an uninitialized memory area, defined
       by the range
	  [first, last)	as if by for (;	first != last; ++first)
	      ::new (/*	VOIDIFY	*/(*first))
		  typename std::iterator_traits<ForwardIt>::value_type(value);
	  where	/* VOIDIFY */(e) is:

	  static_cast<void*>(&e)		(until C++11)
	  static_cast<void*>(std::addressof(e))	(since C++11)

	  If an	exception is thrown during the initialization, the objects al-
       ready constructed
	  are destroyed	in an unspecified order.
	  2) Same as (1), but executed according to policy. This overload par-
       ticipates in
	  overload resolution only if

	  std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>  is	 true.
       (until
										    C++20)
	  std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>  is
       true. (since
										    C++20)

Parameters
	  first, last	       -	 the range of the elements to initial-
       ize
	  value		       -	 the value to construct	 the  elements
       with
	  policy	       -	 the execution policy to use. See exe-
       cution policy for
					 details.

Type requirements
	  -
	  ForwardIt must meet the requirements of LegacyForwardIterator.
	  -
	  No  increment,  assignment, comparison, or indirection through valid
       instances of
	  ForwardIt may	throw exceptions.
	  Applying &* to a ForwardIt value must	yield a	pointer	to  its	 value
       type.
	  (until C++11)

Return value
	  (none)

Complexity
	  Linear in the	distance between first and last.

Exceptions
	  The overload with a template parameter named ExecutionPolicy reports
       errors as
	  follows:

	    *  If  execution  of  a  function invoked as part of the algorithm
       throws an exception
	      and ExecutionPolicy is one of the	standard policies, std::termi-
       nate is called.
	      For any other ExecutionPolicy, the behavior  is  implementation-
       defined.
	    *  If  the	algorithm  fails to allocate memory, std::bad_alloc is
       thrown.

Possible implementation
	  template<class ForwardIt, class T>
	  void uninitialized_fill(ForwardIt first, ForwardIt  last,  const  T&
       value)
	  {
	      using V =	typename std::iterator_traits<ForwardIt>::value_type;
	      ForwardIt	current	= first;
	      try
	      {
		  for (; current != last; ++current)
		      ::new	(static_cast<void*>(std::addressof(*current)))
       V(value);
	      }
	      catch (...)
	      {
		  for (; first != current; ++first)
		      first->~V();
		  throw;
	      }
	  }

Example
       // Run this code

	#include <algorithm>
	#include <iostream>
	#include <memory>
	#include <string>

	int main()
	{
	    const std::size_t sz = 4;
	    std::allocator<std::string>	alloc;
	    std::string* p = alloc.allocate(sz);

	    std::uninitialized_fill(p, p + sz, "Example");

	    for	(std::string* i	= p; i != p + sz; ++i)
	    {
		std::cout << *i	<< '\n';
		i->~basic_string<char>();
	    }

	    alloc.deallocate(p,	sz);
	}

Output:
Example
Example
Example
Example
	  Defect reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	   Applied to	       Behavior	as published		  Cor-
       rect behavior
			      given T as the value type	of ForwardIt,
	  LWG  866   C++98	 if					  uses
       global replacement-
			      T::operator  new exists, the program     new in-
       stead
			      might be ill-formed
	  LWG 2433 C++11      this algorithm might  be	hijacked  by	  uses
       std::addressof
			      overloaded operator&
	  LWG  3870  C++20	 this  algorithm might create objects on  kept
       disallowed
			      a	const storage

See also
				     copies an object to an uninitialized area
       of memory,
	  uninitialized_fill_n	     defined by	a start	and a count
				     (function template)
	  ranges::uninitialized_fill copies an object to an uninitialized area
       of memory,
	  (C++20)		     defined by	a range
				     (niebloid)

http://cppreference.com		  2024.06.10	    std::uninitialized_fill(3)

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

home | help