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; (deprecated 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 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¶

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 exception-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-allocator
(C++11) construction
(class template)