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

NAME
     std::raw_storage_iterator - std::raw_storage_iterator

Synopsis
	Defined in header <memory>
	template< class OutputIt, class T >

	class	raw_storage_iterator					  (until
     C++17)

	    : public std::iterator<std::output_iterator_tag, void,
	void, void, void>;
	template< class OutputIt, class  T  >				  (since
     C++17)
	class  raw_storage_iterator;					 (depre-
     cated in C++17)
								       (removed
     in C++20)

	The output iterator  std::raw_storage_iterator	makes  it  possible  for
     standard
	algorithms  to store results in uninitialized memory. Whenever the algo-
     rithm writes
	an object of type T to the dereferenced iterator, the  object  is  copy-
     constructed
	into  the location in the uninitialized storage pointed to by the itera-
     tor. The
	template parameter OutputIt is any type that meets the requirements of
	LegacyOutputIterator and has operator* defined to return an object,  for
     which
	operator&  returns an object of type T*. Usually, the type T* is used as
     OutputIt.

Type requirements
	-
	OutputIt must meet the requirements of LegacyOutputIterator.

Member functions
	constructor	creates a new raw_storage_iterator
			(public member function)
	operator=	constructs an object at the pointed-to location  in  the
     buffer
			(public member function)
	operator*	dereferences the iterator
			(public member function)
	operator++	advances the iterator
	operator++(int) (public member function)
	base		provides access to the wrapped iterator
	(since C++17)	(public member function)

Member types
	Member type	  Definition
	iterator_category std::output_iterator_tag
	value_type	  void
	difference_type   void		 (until C++20)
			  std::ptrdiff_t (since C++20)
	pointer 	  void
	reference	  void

	Member types iterator_category, value_type, difference_type, pointer
	and   reference   are	required  to  be  obtained  by	inheriting  from
     (until C++17)
	std::iterator<std::output_iterator_tag, void, void, void, void>.

Note
	std::raw_storage_iterator was deprecated primarily because of its excep-
     tion-unsafe
	behavior. Unlike std::uninitialized_copy, it doesn't  handle  exceptions
     during
	operations  like std::copy safely, potentially leading to resource leaks
     due to a
	lack of tracking the number  of  successfully  constructed  objects  and
     their proper
	destruction in the presence of exceptions.

Example
     // Run this code

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

      int main()
      {
	  const std::string s[] = {"This", "is", "a", "test", "."};
	  std::string* p = std::allocator<std::string>().allocate(5);

	  std::copy(std::begin(s), std::end(s),
		    std::raw_storage_iterator<std::string*, std::string>(p));

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

Output:
      This
      is
      a
      test
      .

See also
	allocator_traits	 provides information about allocator types
	(C++11) 		 (class template)
	scoped_allocator_adaptor  implements  multi-level  allocator  for multi-
     level containers
	(C++11) 		 (class template)
	uses_allocator		 checks if the specified type supports	uses-al-
     locator
	(C++11) 		 construction
				 (class template)

http://cppreference.com 	   2024.06.10	    std::raw_storage_iterator(3)
home | help