std::raw_storage_iterator (3) - Linux Manuals

std::raw_storage_iterator: std::raw_storage_iterator


std::raw_storage_iterator - std::raw_storage_iterator


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; (deprecated)
                                                                           (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 algorithm 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 iterator. 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

                creates a new raw_storage_iterator
constructor (public member function)
                constructs an object at the pointed-to location in the buffer
operator= (public member function)
                dereferences the iterator
operator* (public member function)
                advances the iterator
operator++ (public member function)

base provides access to the wrapped iterator
                (public member function)
(since C++17)

Member types

Member type Definition
value_type void
difference_type void
pointer void
reference void
iterator_category std::output_iterator_tag

These member types are required to be obtained by inheriting from std::iterator<std::output_iterator_tag, void, void, void, void>. (until C++17)


// Run this code

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

  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';
      std::allocator<std::string>().deallocate(p, 5);



See also

allocator_traits provides information about allocator types
                         (class template)

scoped_allocator_adaptor implements multi-level allocator for multi-level containers
                         (class template)

uses_allocator checks if the specified type supports uses-allocator construction
                         (class template)