`namespace __gnu_cxx`

.
`__mutex`

, and `__scoped_lock`

.
`__mutex`

reference, and
-locks it during construction of `__scoped_locke`

and
+locks it during construction of `__scoped_lock`

and
unlocks it during destruction. This is an efficient way of locking
critical sections, while retaining exception-safety.
+These types have been superseded in the ISO C++ 2011 standard by the
+mutex and lock types defined in the header
+`bitset<N>`

, then their names and signatures are:
`operator[]`

are not specified
- in the C++ standard. A long-standing defect report calls for sensible
- obvious semantics, which are already implemented here: `op[]`

- on a const bitset returns a bool, and for a non-const bitset returns a
- `reference`

(a nested type). However, this implementation does
- no range-checking on the index argument, which is in keeping with other
- containers' `op[]`

requirements. The defect report's proposed
- resolution calls for range-checking to be done. We'll just wait and see...
+`operator[]`

on a const bitset returns
+ a bool, and for a non-const bitset returns a `reference`

(a
+ nested type). No range-checking is done on the index argument, in keeping
+ with other containers' `operator[]`

requirements.
`<hash_map>`

and `<hash_set>`

+ `<rope>`

is the
- SGI specialization for large strings ("rope,"
- "large strings," get it? Love that geeky humor.)
- `<slist>`

is a singly-linked list, for when the
- doubly-linked `list<>`

is too much space
- overhead, and `<rb_tree>`

exposes the red-black
- tree classes used in the implementation of the standard maps and
- sets.
+ as discussed further below.
+ `list<>`

+ is too much space overhead, and
+ `identity_element`

for addition and multiplication. *
+ `identity_element`

for addition and multiplication.
`identity`

, whose `operator()`

- returns the argument unchanged. *
+ returns the argument unchanged.
`unary_function`

and
`binary_function`

, and their helpers `compose1`

- and `compose2`

. *
+ and `compose2`

.
`select1st`

and `select2nd`

, to strip pairs. *
+ `select1st`

and `select2nd`

, to strip pairs.
`project1st`

and `project2nd`

. * `project1st`

and `project2nd`

. `constant_void_fun`

, `constant_binary_fun`

,
`constant_unary_fun`

, `constant0`

,
- `constant1`

, and `constant2`

. * `subtractive_rng`

. * `constant1`

, and `constant2`

.
+ `subtractive_rng`

. `mem_fun1`

and
`mem_fun1_ref`

are provided for backwards compatibility. `temporary_buffer`

is given in stl_tempbuf.h. *
+ A class `temporary_buffer`

is given in stl_tempbuf.h.
`uninitialized_copy_n`

. *
+ `uninitialized_copy_n`

.
`accumulate`

,
+ are extended with the following functions:
`x ** n`

" where
+ `n >= 0`

. In the
+ case of `n == 0`

, returns the identity element for the
monoid operation. The two-argument signature uses multiplication (for
a true "power" implementation), but addition is supported as well.
The operation functor must be associative.
`iota`

function wins the award for Extension With the
- Coolest Name. It "assigns sequentially increasing values to a range.
- That is, it assigns value to *first, value + 1 to *(first + 1) and so
- on." Quoted from SGI documentation.
+ Coolest Name (the name comes from Ken Iverson's APL language.) As
+ described in the SGI
+ documentation, it "assigns sequentially increasing values to a range.
+ That is, it assigns `value`

to `*first`

,
+ `value + 1`

to` *(first + 1)`

and so on."
`iota`

function is included in the ISO C++ 2011 standard.
+