160 lines
5.0 KiB
Plaintext
160 lines
5.0 KiB
Plaintext
[/
|
|
/ Copyright (c) 2001 Jaakko Järvi
|
|
/
|
|
/ Distributed under the Boost Software License, Version 1.0. (See
|
|
/ accompanying file LICENSE_1_0.txt or copy at
|
|
/ http://www.boost.org/LICENSE_1_0.txt)
|
|
/]
|
|
|
|
[article Tuple library advanced features
|
|
[quickbook 1.6]
|
|
[id tuple_advanced_interface]
|
|
[copyright 2001 Jaakko J\u00E4rvi]
|
|
[license Distributed under the
|
|
[@http://boost.org/LICENSE_1_0.txt Boost Software License,
|
|
Version 1.0].
|
|
]
|
|
]
|
|
|
|
[template simplesect[title]
|
|
[block '''<simplesect><title>'''[title]'''</title>''']]
|
|
|
|
[template endsimplesect[]
|
|
[block '''</simplesect>''']]
|
|
|
|
The advanced features described in this document are all under namespace
|
|
`::boost::tuples`
|
|
|
|
[section Metafunctions for tuple types]
|
|
|
|
Suppose `T` is a tuple type, and `N` is a constant integral expression.
|
|
|
|
element<N, T>::type
|
|
|
|
gives the type of the `N`-th element in the tuple type `T`. If `T` is `const`,
|
|
the resulting type is `const` qualified as well. Note that the constness of `T`
|
|
does not affect reference type elements.
|
|
|
|
length<T>::value
|
|
|
|
gives the length of the tuple type `T`.
|
|
|
|
[endsect]
|
|
|
|
[section Cons lists]
|
|
|
|
Tuples are internally represented as /cons lists/. For example, the tuple
|
|
|
|
tuple<A, B, C, D>
|
|
|
|
inherits from the type
|
|
|
|
cons<A, cons<B, cons<C, cons<D, null_type> > > >
|
|
|
|
The tuple template provides the typedef inherited to access the cons list
|
|
representation. E.g.: `tuple<A>::inherited` is the type `cons<A, null_type>`.
|
|
|
|
[section Empty tuple]
|
|
|
|
The internal representation of the empty tuple `tuple<>` is `null_type`.
|
|
|
|
[endsect]
|
|
|
|
[section Head and tail]
|
|
|
|
Both tuple template and the cons templates provide the typedefs `head_type`
|
|
and `tail_type`. The `head_type` typedef gives the type of the first element
|
|
of the tuple (or the cons list). The `tail_type` typedef gives the remaining
|
|
cons list after removing the first element. The head element is stored in the
|
|
member variable `head` and the tail list in the member variable `tail`. Cons
|
|
lists provide the member function `get_head()` for getting a reference to the
|
|
head of a cons list, and `get_tail()` for getting a reference to the tail.
|
|
There are const and non-const versions of both functions.
|
|
|
|
Note that in a one element tuple, `tail_type` equals `null_type` and the
|
|
`get_tail()` function returns an object of type `null_type`.
|
|
|
|
The empty tuple (`null_type`) has no head or tail, hence the `get_head` and
|
|
`get_tail` functions are not provided.
|
|
|
|
Treating tuples as cons lists gives a convenient means to define generic
|
|
functions to manipulate tuples. For example, the following pair of function
|
|
templates assign `0` to each element of a tuple (obviously, the assignments
|
|
must be valid operations for the element types):
|
|
|
|
inline void set_to_zero(const null_type&) {};
|
|
|
|
template <class H, class T>
|
|
inline void set_to_zero(cons<H, T>& x) { x.get_head() = 0; set_to_zero(x.get_tail()); }
|
|
|
|
[endsect]
|
|
|
|
[section Constructing cons lists]
|
|
|
|
A cons list can be default constructed provided that all its elements can be
|
|
default constructed.
|
|
|
|
A cons list can be constructed from its head and tail. The prototype of the
|
|
constructor is:
|
|
|
|
cons(typename access_traits<head_type>::parameter_type h, const tail_type& t)
|
|
|
|
The traits template for the head parameter selects correct parameter types for
|
|
different kinds of element types (for reference elements the parameter type
|
|
equals the element type, for non-reference types the parameter type is a
|
|
reference to const non-volatile element type).
|
|
|
|
For a one-element cons list the tail argument (`null_type`) can be omitted.
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|
|
|
|
[section Traits classes for tuple element types]
|
|
|
|
[section access_traits]
|
|
|
|
The template `access_traits` defines three type functions. Let `T` be a type
|
|
of an element in a tuple:
|
|
|
|
* `access_traits<T>::non_const_type` maps `T` to the return type of the no
|
|
n-const access functions (nonmember and member `get` functions, and the
|
|
`get_head` function).
|
|
|
|
* `access_traits<T>::const_type` maps `T` to the return type of the const
|
|
access functions.
|
|
|
|
* `access_traits<T>::parameter_type` maps `T` to the parameter type of the
|
|
tuple constructor.
|
|
|
|
[endsect]
|
|
|
|
[section make_tuple_traits]
|
|
|
|
The element types of the tuples that are created with the `make_tuple`
|
|
functions are computed with the type function `make_tuple_traits`. The type
|
|
function call `make_tuple_traits<T>::type` implements the following type
|
|
mapping:
|
|
|
|
* /any reference type/ -> /compile time error/
|
|
|
|
* /any array type/ -> /constant reference to the array type/
|
|
|
|
* `reference_wrapper<T>` -> `T&`
|
|
|
|
* `T` -> `T`
|
|
|
|
Objects of type `reference_wrapper` are created with the `ref` and `cref`
|
|
functions (see [link tuple.constructing_tuples.make_tuple The `make_tuple`
|
|
function]).
|
|
|
|
Reference wrappers were originally part of the tuple library, but they are now
|
|
a general utility of boost. The `reference_wrapper` template and the `ref` and
|
|
`cref` functions are defined in a separate file
|
|
[@boost:/libs/core/doc/html/core/ref.html `ref.hpp`] in the main boost include
|
|
directory; and directly in the `boost` namespace.
|
|
|
|
[endsect]
|
|
|
|
[endsect]
|