std::raw_storage_iterator

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Dynamic memory management

Smart pointers
unique_ptr (C++11)
shared_ptr (C++11)
weak_ptr (C++11)
auto_ptr (deprecated)
owner_less (C++11)
enable_shared_from_this (C++11)
bad_weak_ptr (C++11)
default_delete (C++11)
Allocators
allocator
allocator_traits (C++11)
allocator_arg_t (C++11)
allocator_arg (C++11)
uses_allocator (C++11)
scoped_allocator_adaptor (C++11)
Uninitialized storage
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Garbage collection support
declare_reachable (C++11)
undeclare_reachable (C++11)
declare_no_pointers (C++11)
undeclare_no_pointers (C++11)
pointer_safety (C++11)
get_pointer_safety (C++11)
Miscellaneous
pointer_traits (C++11)
addressof (C++11)
align (C++11)
C Library
malloc calloc	realloc free
Low level memory management

 

std::allocator

Member functions

allocator::allocator

allocator::~allocator

allocator::address

allocator::allocate

allocator::deallocate

allocator::max_size

allocator::construct

allocator::destroy

Non-member functions

operator== operator!=

 

Defined in header <memory>
template< class OutputIt, class T > class raw_storage_iterator     : public std::iterator<std::output_iterator_tag, void, void, void, void>;

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 thee requirements of OutputIterator 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 OutputIterator.

Member functions

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

Inherited from std::iterator

Member types

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

Example

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::get_temporary_buffer<std::string>(5).first;
 
    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::return_temporary_buffer(p);
}

Output:

This
is
a
test
.

See also

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