1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Tuple library advanced features</title>
<body bgcolor="#FFFFFF" text="#000000">
<IMG SRC="../../../c++boost.gif"
ALT="C++ Boost" width="277" height="86">
</head>
<body>
<h1>Tuple library advanced features</h1>
The advanced features described in this document are all under namespace <code>::boost::tuples</code>
<h2>Metafunctions for tuple types</h2>
<p>
Suppose <code>T</code> is a tuple type, and <code>N</code> is a constant integral expression.
<code><pre>element<N, T>::type</pre></code>
gives the type of the <code>N</code>th element in the tuple type <code>T</code>.
</p>
<code><pre>length<T>::value</pre></code>
gives the length of the tuple type <code>T</code>.
</p>
<h2>Cons lists</h2>
<p>
Tuples are internally represented as <i>cons lists</i>.
For example, the tuple
<code><pre>tuple<A, B, C, D></pre></code>
inherits from the type
<code><pre>cons<A, cons<B, cons<C, cons<D, null_type> > > >
</pre></code>
The tuple template provides the typedef <code>inherited</code> to access the cons list representation. E.g.:
<code>tuple<A>::inherited</code> is the type <code>cons<A, null_type></code>.
</p>
<h4>Empty tuple</h4>
<p>
The internal representation of the empty tuple <code>tuple<></code> is <code>null_type</code>.
</p>
<h4>Head and tail</h4>
<p>
Both tuple template and the cons templates provide the typedefs <code>head_type</code> and <code>tail_type</code>.
The <code>head_type</code> typedef gives the type of the first element of the tuple (or the cons list).
The
<code>tail_type</code> typedef gives the remaining cons list after removing the first element.
The head element is stored in the member variable <code>head</code> and the tail list in the member variable <code>tail</code>.
Cons lists provide the member function <code>get_head()</code> for getting a reference to the head of a cons list, and <code>get_tail()</code> for getting a reference to the tail.
There are const and non-const versions of both functions.
</p>
<p>
Note that in a one element tuple, <code>tail_type</code> equals <code>null_type</code> and the <code>get_tail()</code> function returns an object of type <code>null_type</code>.
</p>
<p>
The empty tuple (<code>null_type</code>) has no head or tail, hence the <code>get_head</code> and <code>get_tail</code> functions are not provided.
</p>
<p>
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):
<pre><code>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()); }
</code></pre>
<p>
<h4>Constructing cons lists</h4>
<p>
A cons list can be default constructed provided that all its elements can be default constructed.
</p>
<p>
A cons list can be constructed from its head and tail. The prototype of the constructor is:
<pre><code>cons(typename access_traits<head_type>::parameter_type h,
const tail_type& t)
</code></pre>
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).
</p>
<p>
For a one-element cons list the tail argument (<code>null_type</code>) can be omitted.
</p>
<h2>Traits classes for tuple element types</h2>
<h4><code>access_traits</code></h4>
<p>
The template <code>access_traits</code> defines three type functions. Let <code>T</code> be a type of an element in a tuple:
<ol>
<li><code>access_traits<T>::type</code> maps <code>T</code> to the return type of the non-const access functions (nonmeber and member <code>get</code> functions, and the <code>get_head</code> function).</li>
<li><code>access_traits<T>::const_type</code> maps <code>T</code> to the return type of the const access functions.</li>
<li><code>access_traits<T>::parameter_type</code> maps <code>T</code> to the parameter type of the tuple constructor.</li>
</ol>
<h4><code>make_tuple_traits</code></h4>
The element types of the tuples that are created with the <code>make_tuple</code> functions are computed with the type function <code>make_tuple_traits</code>.
The type function call <code>make_tuple_traits<T>::type</code> implements the following type mapping:
<ul>
<li><i>any reference type</i> -> <i>compile time error</i>
</li>
<li><i>any array type</i> -> <i>constant reference to the array type</i>
</li>
<li><code>reference_wrapper<T></code> -> <code>T&</code>
</li>
<li><code>T</code> -> <code>T</code>
</li>
</ul>
Objects of type <code>reference_wrapper</code> are created with the <code>ref</code> and <code>cref</code> functions (see <A href="tuple_users_guide.html#make_tuple">The <code>make_tuple</code> function</A>.)
</p>
<p>Reference wrappers were originally part of the tuple library, but they are now a general utility of boost.
The <code>reference_wrapper</code> template and the <code>ref</code> and <code>cref</code> functions are defined in a separate file <code>ref.hpp</code> in the main boost include directory; and directly in the <code>boost</code> namespace.
</p>
<A href="tuple_users_guide.html">Back to the user's guide</A>
<hr>
<p>© Copyright Jaakko Järvi 2001.</p>
</body>
</html>
|
