# temporary_buffer<ForwardIterator, T>

Category: allocators | Component type: type

### Description

Some algorithms, such as `stable_sort` and `inplace_merge`, are adaptive: they attempt to use extra temporary memory to store intermediate results, and their run-time complexity is better if that extra memory is available. These algorithms use `temporary_buffer` to allocate that extra memory.

`temporary_buffer`'s constructor takes two arguments, `first` and `last`, of type `ForwardIterator`; the constructor allocates a buffer that is large enough to contain `N` objects of type `T`, where `0 <= N <= last - first` [1], and it fills the buffer with objects of type `T`. The member functions `begin()` and `end()` return iterators that point to the beginning and the end of the buffer.

Note that the elements in the buffer are guaranteed to be initialized; that is, `begin()` points to an object of type `T`, not to raw memory. However, the initial values of the buffer's elements are unspecified. You should not rely on them to be initialized to any particular value.

`temporary_buffer` does not have a copy constructor, or an assignment operator. Those operations would have complicated, and not terribly useful, semantics.

(Earlier versions of the STL used `get_temporary_buffer` and `return_temporary_buffer` instead of `temporary_buffer`. `temporary_buffer` is more convenient, because it does not require using `uninitialized_copy`, and in some cases it is also more efficient. Additionally, it is much easier to write exception-safe code with `temporary_buffer` than with `get_temporary_buffer` and `return_temporary_buffer`.)

### Example

    int main()
    {
      vector<int> V(50);
      iota(V.begin(), V.end(), 1);

      temporary_buffer<vector<int>::iterator, int> buf(V.begin(), V.end());
      copy(V.rbegin(), V.rbegin() + buf.size(), buf.begin());
      copy(buf.begin(), buf.end(), ostream_iterator<int>(cout, "\n"));
    }

### Definition

Defined in the standard header memory, and in the nonstandard backward-compatibility header algo.h. This class is an SGI extension; it is not part of the C++ standard.

### Template parameters

Parameter | Description | Default
--- | --- | ---
`ForwardIterator` | The type of the iterators passed as arguments to `temporary_buffer`'s constructor. |
`T` | The type of object stored in the temporary buffer. | `iterator_traits<ForwardIterator>::value_type` [2]

### Model of

None. `temporary_buffer` is vaguely similar to a Container, but it does not provide the entire Container interface. In particular, it is not a model of DefaultConstructible or Assignable.

### Type requirements

- `ForwardIterator` is a model of Forward Iterator
- `ForwardIterator` is mutable.
- `T` has a constructor that can take a single argument of `ForwardIterator`'s value type.

### Public base classes

None.

### Members

Member | Description
--- | ---
    temporary_buffer(ForwardIterator first,
                     ForwardIterator last)
| Allocates a temporary buffer that holds at most `last - first` elements of type `T`, and constructs those elements. The initial values of the elements are unspecified. Precondition: `[first, last)` is a valid range.
`~temporary_buffer()` | Destroys the elements in the temporary buffer, and deallocates the buffer itself.
`T* begin()` | Returns a pointer to the first element in the buffer.
`T* end()` | Returns a pointer that points one past the last element in the buffer.
`ptrdiff_t requested_size() const` | Returns the value `last - first`, where `first` and `last` are the arguments that were passed to the constructor.
`ptrdiff_t size() const` | Returns the number of elements in the temporary buffer, `end() - begin()`. The return value satisfies the constraint `0 <= size() <= requested_size()`.

### New members

### Notes

[1] The requested size is `last - first`. The size of the temporary buffer is never larger than the requested size, but it might well be smaller; the size might even be zero. The intention is that `temporary_buffer` will allocate as large a buffer as is possible without hurting performance. Note that determining this maximum size is quite difficult: it depends on cache size, physical versus virtual memory, heap fragmentation, and so on. A good implementation of `temporary_buffer` must be nonportable.

[2] The iterator_traits mechanism relies on partial specialization of templates. If your compiler does not yet implement this features, then you will not be able to use this default parameter; you will have to provide both template arguments.

### See also

Copyright © 1999 Silicon Graphics, Inc. All Rights Reserved. TrademarkInformation