std:: raw_storage_iterator
Defined in header
<memory>
|
||
template
<
class
OutputIt,
class
T
>
class
raw_storage_iterator
|
(until C++17) | |
template
<
class
OutputIt,
class
T
>
class raw_storage_iterator ; |
(since C++17)
(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
creates a new
raw_storage_iterator
(public member function) |
|
constructs an object at the pointed-to location in the buffer
(public member function) |
|
dereferences the iterator
(public member function) |
|
advances the iterator
(public member function) |
|
(since C++17)
|
provides access to the wrapped iterator
(public member function) |
Member types
Member type | Definition | ||||
iterator_category
|
std:: output_iterator_tag | ||||
value_type
|
void | ||||
difference_type
|
|
||||
pointer
|
void | ||||
reference
|
void |
Member types
|
(until C++17) |
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
#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
(C++11)
|
provides information about allocator types
(class template) |
(C++11)
|
implements multi-level allocator for multi-level containers
(class template) |
(C++11)
|
checks if the specified type supports uses-allocator construction
(class template) |