123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159 |
- [/
- / 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]
|