Standard Template Library Programmer's Guide

[2] The declarations for rfirst and rlast are written in this clumsy form simply as an illustration of how to declare a reverse_bidirectional_iterator . List is a Reversible Container, so it provides a typedef for the appropriate instantiation of reverse_bidirectional_iterator . The usual way of declaring these variables is much simpler:

list::reverse_bidirectional_iterator rfirst = rbegin();

list::reverse_bidirectional_iterator rlast = rend();

[3] Note the implications of this remark. The variable rfirst is initialized as reverse_bidirectional_iterator<���…> rfirst(V.end()); . The value obtained when it is dereferenced, however, is *(V.end() – 1) . This is a general property: the fundamental identity of reverse iterators is &*(reverse_bidirectional_iterator(i)) == &*(i – 1) . This code sample shows why this identity is important: if [f, l) is a valid range, then it allows [reverse_bidirectional_iterator(l), reverse_bidirectional_iterator(f)) to be a valid range as well. Note that the iterator l is not part of the range, but it is required to be dereferenceable or past-the-end. There is no requirement that any such iterator precedes f .

Reversible Container, reverse_iterator, Bidirectional Iterator, iterator tags, Iterator overview

Categories: allocators, iterators, adaptors

Component type: type

In C++, the operator new allocates memory for an object and then creates an object at that location by calling a constructor. Occasionally, however, it is useful to separate those two operations. [1] If i is an iterator that points to a region of uninitialized memory, then you can use construct to create an object in the location pointed to by i . Raw_storage_iterator is an adaptor that makes this procedure more convenient. If r is a raw_storage_iterator , then it has some underlying iterator i . The expression *r = x is equivalent to construct(&*i, x) .

class Int {

public:

Int(int x) : val(x) {}

int get() { return val; }

private:

int val;

};

int main() {

int A1[] = {1, 2, 3, 4, 5, 6, 7};

const int N = sizeof(A1) / sizeof(int);

Int* A2 = (Int*)malloc(N * sizeof(Int));

transform(A1, A1 + N, raw_storage_iterator(A2), negate());

}

Defined in the standard header memory, and in the nonstandard backward-compatibility header iterator.h.

Output Iterator

• ForwardIterator is a model of Forward Iterator

• ForwardIterator 's value type has a constructor that takes a single argument of type T .

None.

These members are not defined in the Output Iterator requirements, but are specific to raw_storage_iterator .

[1] In particular, this sort of low-level memory management is used in the implementation of some container classes.

[2] Note how assignment through a raw_storage_iterator is implemented. In general, unary operator* must be defined so that it returns a proxy object, where the proxy object defines operator= to perform the insert operation. In this case, for the sake of simplicity, the proxy object is the raw_storage_iterator itself. That is, *i returns i , and *i = t is equivalent to i = t . You should not, however, rely on this behavior. It is an implementation detail, and it is not guaranteed to remain the same in future versions.

Allocators, construct , destroy , uninitialized_copy uninitialized_fill , uninitialized_fill_n

Categories: iterators, adaptors

Component type: type

Sequence_buffer is similar to back_insert_iterator : it is an output iterator adaptor that appends elements to the end of a container.

The main difference between sequence_buffer and back_insert_iterator is that back_insert_iterator inserts elements into a sequence one element at a time; sequence_buffer , however, as the "buffer" part of the name suggests, accumulates elements into a buffer and appends the entire buffer in a single operation.

Specifically, the expression *it = v adds v to the end of it 's internal buffer. The buffer is automatically flushed when it gets full, or when it is destroyed; flushing the buffer means emptying it and appending its contents to it 's underlying container. (It is also possible to flush the buffer manually, by invoking the flush() member function.)