<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Composite</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Phoenix 2.0">
<link rel="prev" href="primitives.html" title="Primitives">
<link rel="next" href="container.html" title="Container">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="primitives.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="phoenix.composite"></a><a class="link" href="composite.html" title="Composite">Composite</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="composite.html#phoenix.composite.function">Function</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.operator">Operator</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement">Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.object">Object</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.scope">Scope</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.bind">Bind</a></span></dt>
</dl></div>
<p>
Actors may be combined in a multitude of ways to form composites. Composites
are actors that are composed of zero or more actors. Composition is hierarchical.
An element of the composite can be a primitive or again another composite.
The flexibility to arbitrarily compose hierarchical structures allows us to
form intricate constructions that model complex functions, statements and expressions.
</p>
<p>
A composite is-a tuple of 0..N actors. N is the predefined maximum actors a
composite can take.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
You can set <code class="computeroutput"><span class="identifier">PHOENIX_COMPOSITE_LIMIT</span></code>,
the predefined maximum actors a composite can take. By default, <code class="computeroutput"><span class="identifier">PHOENIX_COMPOSITE_LIMIT</span></code> is set to <code class="computeroutput"><span class="identifier">PHOENIX_LIMIT</span></code> (See <a class="link" href="actors.html" title="Actors">Actors</a>).
</p></td></tr>
</table></div>
<p>
As mentioned, each of the actors A0..AN can, in turn, be another composite,
since a composite is itself an actor. This makes the composite a recursive
structure. The actual evaluation is handled by a composite specific eval policy.
</p>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.function"></a><a class="link" href="composite.html#phoenix.composite.function" title="Function">Function</a>
</h3></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">function</span><span class="special">/</span><span class="identifier">function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The <code class="computeroutput"><span class="identifier">function</span></code> class template
provides a mechanism for implementing lazily evaluated functions. Syntactically,
a lazy function looks like an ordinary C/C++ function. The function call
looks familiar and feels the same as ordinary C++ functions. However, unlike
ordinary functions, the actual function execution is deferred.
</p>
<p>
Unlike ordinary function pointers or functor objects that need to be explicitly
bound through the bind function (see <a class="link" href="composite.html#phoenix.composite.bind" title="Bind">Bind</a>),
the argument types of these functions are automatically lazily bound.
</p>
<p>
In order to create a lazy function, we need to implement a model of the FunctionEval
concept. For a function that takes <code class="computeroutput"><span class="identifier">N</span></code>
arguments, a model of FunctionEval must provide:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
An <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
that implements that takes <code class="computeroutput"><span class="identifier">N</span></code>
arguments, and implements the function logic.
</li>
<li class="listitem">
A nested metafunction <code class="computeroutput"><span class="identifier">result</span><span class="special"><</span><span class="identifier">A1</span><span class="special">,</span> <span class="special">...</span> <span class="identifier">AN</span><span class="special">></span></code>
that takes the types of the <code class="computeroutput"><span class="identifier">N</span></code>
arguments to the function and returns the result type of the function.
(There is a special case for function objects that accept no arguments.
Such nullary functors are only required to define a typedef <code class="computeroutput"><span class="identifier">result_type</span></code> that reflects the return
type of its <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>).
</li>
</ul></div>
<p>
For example, the following type implements the FunctionEval concept, in order
to provide a lazy factorial function:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">factorial_impl</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Arg</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">result</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="identifier">Arg</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">Arg</span><span class="special">></span>
<span class="identifier">Arg</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Arg</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="keyword">return</span> <span class="special">(</span><span class="identifier">n</span> <span class="special"><=</span> <span class="number">0</span><span class="special">)</span> <span class="special">?</span> <span class="number">1</span> <span class="special">:</span> <span class="identifier">n</span> <span class="special">*</span> <span class="keyword">this</span><span class="special">-></span><span class="keyword">operator</span><span class="special">()(</span><span class="identifier">n</span><span class="special">-</span><span class="number">1</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
(See <a href="../../../example/users_manual/factorial.cpp" target="_top">factorial.cpp</a>)
</p>
<p>
Having implemented the <code class="computeroutput"><span class="identifier">factorial_impl</span></code>
type, we can declare and instantiate a lazy <code class="computeroutput"><span class="identifier">factorial</span></code>
function this way:
</p>
<pre class="programlisting"><span class="identifier">function</span><span class="special"><</span><span class="identifier">factorial_impl</span><span class="special">></span> <span class="identifier">factorial</span><span class="special">;</span>
</pre>
<p>
Invoking a lazy function such as <code class="computeroutput"><span class="identifier">factorial</span></code>
does not immediately execute the function object <code class="computeroutput"><span class="identifier">factorial_impl</span></code>.
Instead, an <a class="link" href="actors.html" title="Actors">actor</a> object is created
and returned to the caller. Example:
</p>
<pre class="programlisting"><span class="identifier">factorial</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
</pre>
<p>
does nothing more than return an actor. A second function call will invoke
the actual factorial function. Example:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">4</span><span class="special">;</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>
</pre>
<p>
will print out "24".
</p>
<p>
Take note that in certain cases (e.g. for function objects with state), an
instance of the model of FunctionEval may be passed on to the constructor.
Example:
</p>
<pre class="programlisting"><span class="identifier">function</span><span class="special"><</span><span class="identifier">factorial_impl</span><span class="special">></span> <span class="identifier">factorial</span><span class="special">(</span><span class="identifier">ftor</span><span class="special">);</span>
</pre>
<p>
where ftor is an instance of factorial_impl (this is not necessary in this
case as <code class="computeroutput"><span class="identifier">factorial_impl</span></code> does
not require any state).
</p>
<div class="sidebar">
<p class="title"><b></b></p>
<p>
<span class="inlinemediaobject"><img src="../images/alert.png" alt="alert"></span> Take care though when using function objects with state
because they are often copied repeatedly, and state may change in one of
the copies, rather than the original.
</p>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.operator"></a><a class="link" href="composite.html#phoenix.composite.operator" title="Operator">Operator</a>
</h3></div></div></div>
<p>
This facility provides a mechanism for lazily evaluating operators. Syntactically,
a lazy operator looks and feels like an ordinary C/C++ infix, prefix or postfix
operator. The operator application looks the same. However, unlike ordinary
operators, the actual operator execution is deferred. Samples:
</p>
<pre class="programlisting"><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span>
<span class="number">1</span> <span class="special">+</span> <span class="identifier">arg1</span> <span class="special">*</span> <span class="identifier">arg2</span>
<span class="number">1</span> <span class="special">/</span> <span class="special">-</span><span class="identifier">arg1</span>
<span class="identifier">arg1</span> <span class="special"><</span> <span class="number">150</span>
</pre>
<p>
We have seen the lazy operators in action (see <a class="link" href="starter_kit.html" title="Starter Kit">Quick
Start</a>). Let's go back and examine them a little bit further:
</p>
<pre class="programlisting"><span class="identifier">find_if</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">arg1</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span>
</pre>
<p>
Through operator overloading, the expression <code class="computeroutput"><span class="identifier">arg1</span>
<span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">1</span></code> actually
generates an actor. This actor object is passed on to STL's <code class="computeroutput"><span class="identifier">find_if</span></code> function. From the viewpoint of
STL, the composite is simply a function object expecting a single argument
of the containers value_type. For each element in <code class="computeroutput"><span class="identifier">c</span></code>,
the element is passed on as an argument <code class="computeroutput"><span class="identifier">arg1</span></code>
to the actor (function object). The actor checks if this is an odd value
based on the expression <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span>
<span class="number">1</span></code> where arg1 is replaced by the container's
element.
</p>
<p>
Like lazy functions (see <a class="link" href="composite.html#phoenix.composite.function" title="Function">function</a>),
lazy operators are not immediately executed when invoked. Instead, an actor
(see <a class="link" href="actors.html" title="Actors">actors</a>) object is created and
returned to the caller. Example:
</p>
<pre class="programlisting"><span class="special">(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">arg3</span>
</pre>
<p>
does nothing more than return an actor. A second function call will evaluate
the actual operators. Example:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">4</span><span class="special">,</span> <span class="identifier">j</span> <span class="special">=</span> <span class="number">5</span><span class="special">,</span> <span class="identifier">k</span> <span class="special">=</span> <span class="number">6</span><span class="special">;</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="special">((</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">arg3</span><span class="special">)(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">j</span><span class="special">,</span> <span class="identifier">k</span><span class="special">);</span>
</pre>
<p>
will print out "54".
</p>
<p>
Operator expressions are lazily evaluated following four simple rules:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
A binary operator, except <code class="computeroutput"><span class="special">->*</span></code>
will be lazily evaluated when <span class="emphasis"><em>at least</em></span> one of its
operands is an actor object (see <a class="link" href="actors.html" title="Actors">actors</a>).
</li>
<li class="listitem">
Unary operators are lazily evaluted if their argument is an actor object.
</li>
<li class="listitem">
Operator <code class="computeroutput"><span class="special">->*</span></code> is lazily
evaluted if the left hand argument is an actor object.
</li>
<li class="listitem">
The result of a lazy operator is an actor object that can in turn allow
the applications of rules 1 and 2.
</li>
</ol></div>
<p>
For example, to check the following expression is lazily evaluated:
</p>
<pre class="programlisting"><span class="special">-(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span><span class="special">)</span>
</pre>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
Following rule 1, <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span></code> is
lazily evaluated since <code class="computeroutput"><span class="identifier">arg1</span></code>
is an actor (see <a class="link" href="primitives.html" title="Primitives">primitives</a>).
</li>
<li class="listitem">
The result of this <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span></code> expression
is an actor object, following rule 4.
</li>
<li class="listitem">
Continuing, <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span>
<span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is again lazily evaluated. Rule 2.
</li>
<li class="listitem">
By rule 4 again, the result of <code class="computeroutput"><span class="identifier">arg1</span>
<span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is
an actor object.
</li>
<li class="listitem">
As <code class="computeroutput"><span class="identifier">arg1</span> <span class="special">+</span>
<span class="number">3</span> <span class="special">+</span> <span class="number">6</span></code> is an actor, <code class="computeroutput"><span class="special">-(</span><span class="identifier">arg1</span> <span class="special">+</span> <span class="number">3</span> <span class="special">+</span> <span class="number">6</span><span class="special">)</span></code> is lazily evaluated. Rule 2.
</li>
</ol></div>
<p>
Lazy-operator application is highly contagious. In most cases, a single
<code class="computeroutput"><span class="identifier">argN</span></code> actor infects all its
immediate neighbors within a group (first level or parenthesized expression).
</p>
<p>
Note that at least one operand of any operator must be a valid actor for
lazy evaluation to take effect. To force lazy evaluation of an ordinary expression,
we can use <code class="computeroutput"><span class="identifier">ref</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">val</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> or <code class="computeroutput"><span class="identifier">cref</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
to transform an operand into a valid actor object (see <a class="link" href="primitives.html" title="Primitives">primitives</a>.
For example:
</p>
<pre class="programlisting"><span class="number">1</span> <span class="special"><<</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// Immediately evaluated
</span><span class="identifier">val</span><span class="special">(</span><span class="number">1</span><span class="special">)</span> <span class="special"><<</span> <span class="number">3</span><span class="special">;</span> <span class="comment">// Lazily evaluated
</span></pre>
<a name="phoenix.composite.operator.supported_operators"></a><h3>
<a name="id771576"></a>
<a class="link" href="composite.html#phoenix.composite.operator.supported_operators">Supported
operators</a>
</h3>
<a name="phoenix.composite.operator.unary_operators"></a><h4>
<a name="id771597"></a>
<a class="link" href="composite.html#phoenix.composite.operator.unary_operators">Unary operators</a>
</h4>
<pre class="programlisting"><span class="identifier">prefix</span><span class="special">:</span> <span class="special">~,</span> <span class="special">!,</span> <span class="special">-,</span> <span class="special">+,</span> <span class="special">++,</span> <span class="special">--,</span> <span class="special">&</span> <span class="special">(</span><span class="identifier">reference</span><span class="special">),</span> <span class="special">*</span> <span class="special">(</span><span class="identifier">dereference</span><span class="special">)</span>
<span class="identifier">postfix</span><span class="special">:</span> <span class="special">++,</span> <span class="special">--</span>
</pre>
<a name="phoenix.composite.operator.binary_operators"></a><h4>
<a name="id771727"></a>
<a class="link" href="composite.html#phoenix.composite.operator.binary_operators">Binary operators</a>
</h4>
<pre class="programlisting"><span class="special">=,</span> <span class="special">[],</span> <span class="special">+=,</span> <span class="special">-=,</span> <span class="special">*=,</span> <span class="special">/=,</span> <span class="special">%=,</span> <span class="special">&=,</span> <span class="special">|=,</span> <span class="special">^=,</span> <span class="special"><<=,</span> <span class="special">>>=</span>
<span class="special">+,</span> <span class="special">-,</span> <span class="special">*,</span> <span class="special">/,</span> <span class="special">%,</span> <span class="special">&,</span> <span class="special">|,</span> <span class="special">^,</span> <span class="special"><<,</span> <span class="special">>></span>
<span class="special">==,</span> <span class="special">!=,</span> <span class="special"><,</span> <span class="special">>,</span> <span class="special"><=,</span> <span class="special">>=</span>
<span class="special">&&,</span> <span class="special">||,</span> <span class="special">->*</span>
</pre>
<a name="phoenix.composite.operator.ternary_operator"></a><h4>
<a name="id771926"></a>
<a class="link" href="composite.html#phoenix.composite.operator.ternary_operator">Ternary operator</a>
</h4>
<pre class="programlisting"><span class="identifier">if_else</span><span class="special">(</span><span class="identifier">c</span><span class="special">,</span> <span class="identifier">a</span><span class="special">,</span> <span class="identifier">b</span><span class="special">)</span>
</pre>
<p>
The ternary operator deserves special mention. Since C++ does not allow us
to overload the conditional expression: <code class="computeroutput"><span class="identifier">c</span>
<span class="special">?</span> <span class="identifier">a</span> <span class="special">:</span> <span class="identifier">b</span></code>, the
if_else pseudo function is provided for this purpose. The behavior is identical,
albeit in a lazy manner.
</p>
<a name="phoenix.composite.operator.member_pointer_operator"></a><h4>
<a name="id772030"></a>
<a class="link" href="composite.html#phoenix.composite.operator.member_pointer_operator">Member
pointer operator</a>
</h4>
<pre class="programlisting"><span class="identifier">a</span><span class="special">->*</span><span class="identifier">member_object_pointer</span>
<span class="identifier">a</span><span class="special">->*</span><span class="identifier">member_function_pointer</span>
</pre>
<p>
The left hand side of the member pointer operator must be an actor returning
a pointer type. The right hand side of the member pointer operator may be
either a pointer to member object or pointer to member function.
</p>
<p>
If the right hand side is a member object pointer, the result is an actor
which, when evaluated, returns a reference to that member. For example:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">member</span><span class="special">;</span>
<span class="special">};</span>
<span class="identifier">A</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">A</span><span class="special">;</span>
<span class="special">...</span>
<span class="special">(</span><span class="identifier">arg1</span><span class="special">->*&</span><span class="identifier">A</span><span class="special">::</span><span class="identifier">member</span><span class="special">)(</span><span class="identifier">a</span><span class="special">);</span> <span class="comment">// returns member a->member
</span></pre>
<p>
If the right hand side is a member function pointer, the result is an actor
which, when invoked, calls the specified member function. For example:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">A</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">func</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
<span class="special">};</span>
<span class="identifier">A</span><span class="special">*</span> <span class="identifier">a</span> <span class="special">=</span> <span class="keyword">new</span> <span class="identifier">A</span><span class="special">;</span>
<span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="special">(</span><span class="identifier">arg1</span><span class="special">->*&</span><span class="identifier">A</span><span class="special">::</span><span class="identifier">func</span><span class="special">)(</span><span class="identifier">arg2</span><span class="special">)(</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">i</span><span class="special">);</span> <span class="comment">// returns a->func(i)
</span></pre>
<div class="table">
<a name="id772403"></a><p class="title"><b>Table 1.4. Include Files</b></p>
<div class="table-contents"><table class="table" summary="Include Files">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Operators
</p>
</th>
<th>
<p>
File
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">-</span></code>, <code class="computeroutput"><span class="special">+</span></code>,
<code class="computeroutput"><span class="special">++</span></code>, <code class="computeroutput"><span class="special">--</span></code>, <code class="computeroutput"><span class="special">+=</span></code>,
<code class="computeroutput"><span class="special">-=</span></code>, <code class="computeroutput"><span class="special">*=</span></code>, <code class="computeroutput"><span class="special">/=</span></code>,
<code class="computeroutput"><span class="special">%=</span></code>, <code class="computeroutput"><span class="special">*</span></code>, <code class="computeroutput"><span class="special">/</span></code>,
<code class="computeroutput"><span class="special">%</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">arithmetic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&=</span></code>, <code class="computeroutput"><span class="special">|=</span></code>, <code class="computeroutput"><span class="special">^=</span></code>,
<code class="computeroutput"><span class="special"><<=</span></code>, <code class="computeroutput"><span class="special">>>=</span></code>, <code class="computeroutput"><span class="special">&</span></code>,
<code class="computeroutput"><span class="special">|</span></code>, <code class="computeroutput"><span class="special">^</span></code>,
<code class="computeroutput"><span class="special"><<</span></code>, <code class="computeroutput"><span class="special">>></span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">bitwise</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">==</span></code>, <code class="computeroutput"><span class="special">!=</span></code>, <code class="computeroutput"><span class="special"><</span></code>,
<code class="computeroutput"><span class="special"><=</span></code>, <code class="computeroutput"><span class="special">></span></code>, <code class="computeroutput"><span class="special">>=</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">comparison</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special"><<</span></code>, <code class="computeroutput"><span class="special">>></span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">io</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">!</span></code>, &&, <code class="computeroutput"><span class="special">||</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">logical</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&</span><span class="identifier">x</span></code>,
<code class="computeroutput"><span class="special">*</span><span class="identifier">p</span></code>,
<code class="computeroutput"><span class="special">=</span></code>, <code class="computeroutput"><span class="special">[]</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">self</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">if_else</span><span class="special">(</span><span class="identifier">c</span><span class="special">,</span>
<span class="identifier">a</span><span class="special">,</span>
<span class="identifier">b</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">if_else</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">->*</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="keyword">operator</span><span class="special">/</span><span class="identifier">member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</div>
<br class="table-break">
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.statement"></a><a class="link" href="composite.html#phoenix.composite.statement" title="Statement">Statement</a>
</h3></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.block_statement">Block
Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.if__statement">if_ Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.if_else__statement">if<span class="underline">else</span> statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.switch__statement">switch_
statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.while__statement">while_
Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.do_while__statement">do<span class="underline">while</span> Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.for__statement">for_ Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.try__catch__statement">try_
catch_ Statement</a></span></dt>
<dt><span class="section"><a href="composite.html#phoenix.composite.statement.throw_">throw_</a></span></dt>
</dl></div>
<p>
<span class="bold"><strong><span class="emphasis"><em>Lazy statements...</em></span></strong></span>
</p>
<p>
The primitives and composite building blocks presented so far are sufficiently
powerful to construct quite elaborate structures. We have presented lazy-
functions and lazy-operators. How about lazy-statements? First, an appetizer:
</p>
<p>
Print all odd-numbered contents of an STL container using <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span></code>
(<a href="../../../example/users_manual/all_odds.cpp" target="_top">all_odds.cpp</a>):
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">if_</span><span class="special">(</span><span class="identifier">arg1</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">1</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="char">' '</span>
<span class="special">]</span>
<span class="special">);</span>
</pre>
<p>
Huh? Is that valid C++? Read on...
</p>
<p>
Yes, it is valid C++. The sample code above is as close as you can get to
the syntax of C++. This stylized C++ syntax differs from actual C++ code.
First, the <code class="computeroutput"><span class="keyword">if</span></code> has a trailing
underscore. Second, the block uses square brackets instead of the familiar
curly braces {}.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top">
<p>
<span class="bold"><strong>C++ in C++?</strong></span>
</p>
<p>
In as much as <a href="http://spirit.sourceforge.net" target="_top">Spirit</a>
attempts to mimic EBNF in C++, Phoenix attempts to mimic C++ in C++!!!
</p>
</td></tr>
</table></div>
<p>
Here are more examples with annotations. The code almost speaks for itself.
</p>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.block_statement"></a><a class="link" href="composite.html#phoenix.composite.statement.block_statement" title="Block Statement">Block
Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="identifier">sequence</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Syntax:
</p>
<pre class="programlisting"><span class="identifier">statement</span><span class="special">,</span>
<span class="identifier">statement</span><span class="special">,</span>
<span class="special">....</span>
<span class="identifier">statement</span>
</pre>
<p>
Basically, these are comma separated statements. Take note that unlike
the C/C++ semicolon, the comma is a separator put <span class="bold"><strong>in-between</strong></span>
statements. This is like Pascal's semicolon separator, rather than C/C++'s
semicolon terminator. For example:
</p>
<pre class="programlisting"><span class="identifier">statement</span><span class="special">,</span>
<span class="identifier">statement</span><span class="special">,</span>
<span class="identifier">statement</span><span class="special">,</span> <span class="comment">// ERROR!
</span></pre>
<p>
Is an error. The last statement should not have a comma. Block statements
can be grouped using the parentheses. Again, the last statement in a group
should not have a trailing comma.
</p>
<pre class="programlisting"><span class="identifier">statement</span><span class="special">,</span>
<span class="identifier">statement</span><span class="special">,</span>
<span class="special">(</span>
<span class="identifier">statement</span><span class="special">,</span>
<span class="identifier">statement</span>
<span class="special">),</span>
<span class="identifier">statement</span>
</pre>
<p>
Outside the square brackets, block statements should be grouped. For example:
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="special">(</span>
<span class="identifier">do_this</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">),</span>
<span class="identifier">do_that</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">);</span>
</pre>
<p>
Wrapping a comma operator chain around a parentheses pair blocks the interpretation
as an argument separator. The reason for the exception for the square bracket
operator is that the operator always takes exactly one argument, so it
"transforms" any attempt at multiple arguments with a comma operator
chain (and spits out an error for zero arguments).
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.if__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.if__statement" title="if_ Statement">if_ Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
We have seen the <code class="computeroutput"><span class="identifier">if_</span></code> statement.
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">if_</span><span class="special">(</span><span class="identifier">conditional_expression</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.if_else__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.if_else__statement" title="ifelse statement">if<span class="underline">else</span> statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is
</p>
<pre class="programlisting"><span class="identifier">if_</span><span class="special">(</span><span class="identifier">conditional_expression</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">else_</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
</pre>
<p>
Take note that <code class="computeroutput"><span class="keyword">else</span></code> has a
leading dot and a trailing underscore: <code class="computeroutput"><span class="special">.</span><span class="identifier">else_</span></code>
</p>
<p>
Example: This code prints out all the elements and appends <code class="computeroutput"><span class="string">" > 5"</span></code>, <code class="computeroutput"><span class="string">"
== 5"</span></code> or <code class="computeroutput"><span class="string">" < 5"</span></code>
depending on the element's actual value:
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">if_</span><span class="special">(</span><span class="identifier">arg1</span> <span class="special">></span> <span class="number">5</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">" > 5\n"</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">else_</span>
<span class="special">[</span>
<span class="identifier">if_</span><span class="special">(</span><span class="identifier">arg1</span> <span class="special">==</span> <span class="number">5</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">" == 5\n"</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">else_</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">" < 5\n"</span>
<span class="special">]</span>
<span class="special">]</span>
<span class="special">);</span>
</pre>
<p>
Notice how the <code class="computeroutput"><span class="identifier">if_else_</span></code>
statement is nested.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.switch__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.switch__statement" title="switch_ statement">switch_
statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">switch</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">switch_</span><span class="special">(</span><span class="identifier">integral_expression</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">case_</span><span class="special"><</span><span class="identifier">integral_value</span><span class="special">>(</span><span class="identifier">sequenced_statements</span><span class="special">),</span>
<span class="special">...</span>
<span class="identifier">default_</span><span class="special"><</span><span class="identifier">integral_value</span><span class="special">>(</span><span class="identifier">sequenced_statements</span><span class="special">)</span>
<span class="special">]</span>
</pre>
<p>
A comma separated list of cases, and an optional default can be provided.
Note unlike a normal switch statement, cases do not fall through.
</p>
<p>
Example: This code prints out <code class="computeroutput"><span class="string">"one"</span></code>,
<code class="computeroutput"><span class="string">"two"</span></code> or <code class="computeroutput"><span class="string">"other value"</span></code> depending on the
element's actual value:
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="identifier">switch_</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">case_</span><span class="special"><</span><span class="number">1</span><span class="special">>(</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"one"</span><span class="special">)</span> <span class="special"><<</span> <span class="char">'\n'</span><span class="special">),</span>
<span class="identifier">case_</span><span class="special"><</span><span class="number">2</span><span class="special">>(</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"two"</span><span class="special">)</span> <span class="special"><<</span> <span class="char">'\n'</span><span class="special">),</span>
<span class="identifier">default_</span><span class="special">(</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"other value"</span><span class="special">)</span> <span class="special"><<</span> <span class="char">'\n'</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">);</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.while__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.while__statement" title="while_ Statement">while_
Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">while</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">while_</span><span class="special">(</span><span class="identifier">conditional_expression</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
</pre>
<p>
Example: This code decrements each element until it reaches zero and prints
out the number at each step. A newline terminates the printout of each
value.
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="special">(</span>
<span class="identifier">while_</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">--)</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">", "</span>
<span class="special">],</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"\n"</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">);</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.do_while__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.do_while__statement" title="dowhile Statement">do<span class="underline">while</span> Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="identifier">do_while</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">do_</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">while_</span><span class="special">(</span><span class="identifier">conditional_expression</span><span class="special">)</span>
</pre>
<p>
Again, take note that <code class="computeroutput"><span class="keyword">while</span></code>
has a leading dot and a trailing underscore: <code class="computeroutput"><span class="special">.</span><span class="identifier">while_</span></code>
</p>
<p>
Example: This code is almost the same as the previous example above with
a slight twist in logic.
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="special">(</span>
<span class="identifier">do_</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">", "</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">while_</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">--),</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"\n"</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">);</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.for__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.for__statement" title="for_ Statement">for_ Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">for</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">for_</span><span class="special">(</span><span class="identifier">init_statement</span><span class="special">,</span> <span class="identifier">conditional_expression</span><span class="special">,</span> <span class="identifier">step_statement</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
</pre>
<p>
It is again very similar to the C++ for statement. Take note that the init_statement,
conditional_expression and step<span class="underline">statement are
separated by the comma instead of the semi-colon and each must be present
(i.e. `for</span>(,,)` is invalid). This is a case where the <a class="link" href="primitives.html#phoenix.primitives.nothing" title="Nothing">nothing</a> actor can be useful.
</p>
<p>
Example: This code prints each element N times where N is the element's
value. A newline terminates the printout of each value.
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">iii</span><span class="special">;</span>
<span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span>
<span class="special">(</span>
<span class="identifier">for_</span><span class="special">(</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">iii</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">,</span> <span class="identifier">ref</span><span class="special">(</span><span class="identifier">iii</span><span class="special">)</span> <span class="special"><</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="special">++</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">iii</span><span class="special">))</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span> <span class="special"><<</span> <span class="string">", "</span>
<span class="special">],</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"\n"</span><span class="special">)</span>
<span class="special">)</span>
<span class="special">);</span>
</pre>
<p>
As before, all these are lazily evaluated. The result of such statements
are in fact composites that are passed on to STL's for_each function. In
the viewpoint of <code class="computeroutput"><span class="identifier">for_each</span></code>,
what was passed is just a functor, no more, no less.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Unlike lazy functions and lazy operators, lazy statements always return
void.
</p></td></tr>
</table></div>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.try__catch__statement"></a><a class="link" href="composite.html#phoenix.composite.statement.try__catch__statement" title="try_ catch_ Statement">try_
catch_ Statement</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="identifier">try_catch</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The syntax is:
</p>
<pre class="programlisting"><span class="identifier">try_</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_</span><span class="special"><</span><span class="identifier">exception_type</span><span class="special">>()</span>
<span class="special">[</span>
<span class="identifier">sequenced_statements</span>
<span class="special">]</span>
<span class="special">...</span>
<span class="special">.</span><span class="identifier">catch_all</span>
<span class="special">[</span>
<span class="identifier">sequenced_statement</span>
<span class="special">]</span>
</pre>
<p>
Note the usual underscore after try and catch, and the extra parentheses
required after the catch.
</p>
<p>
Example: The following code calls the (lazy) function <code class="computeroutput"><span class="identifier">f</span></code>
for each element, and prints messages about different exception types it
catches.
</p>
<pre class="programlisting"><span class="identifier">try_</span>
<span class="special">[</span>
<span class="identifier">f</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_</span><span class="special"><</span><span class="identifier">runtime_error</span><span class="special">>()</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught runtime error or derived\n"</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_</span><span class="special"><</span><span class="identifier">exception</span><span class="special">>()</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught exception or derived\n"</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_all</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught some other type of exception\n"</span><span class="special">)</span>
<span class="special">]</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="phoenix.composite.statement.throw_"></a><a class="link" href="composite.html#phoenix.composite.statement.throw_" title="throw_">throw_</a>
</h4></div></div></div>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">statement</span><span class="special">/</span><span class="keyword">throw</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
As a natural companion to the try/catch support, the statement module provides
lazy throwing and rethrowing of exceptions.
</p>
<p>
The syntax to throw an exception is:
</p>
<pre class="programlisting"><span class="identifier">throw_</span><span class="special">(</span><span class="identifier">exception_expression</span><span class="special">)</span>
</pre>
<p>
The syntax to rethrow an exception is:
</p>
<pre class="programlisting"><span class="identifier">throw_</span><span class="special">()</span>
</pre>
<p>
Example: This code extends the try/catch example, rethrowing exceptions
derived from runtime_error or exception, and translating other exception
types to runtime_errors.
</p>
<pre class="programlisting"><span class="identifier">try_</span>
<span class="special">[</span>
<span class="identifier">f</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_</span><span class="special"><</span><span class="identifier">runtime_error</span><span class="special">>()</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught runtime error or derived\n"</span><span class="special">),</span>
<span class="identifier">throw_</span><span class="special">()</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_</span><span class="special"><</span><span class="identifier">exception</span><span class="special">>()</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught exception or derived\n"</span><span class="special">),</span>
<span class="identifier">throw_</span><span class="special">()</span>
<span class="special">]</span>
<span class="special">.</span><span class="identifier">catch_all</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">val</span><span class="special">(</span><span class="string">"caught some other type of exception\n"</span><span class="special">),</span>
<span class="identifier">throw_</span><span class="special">(</span><span class="identifier">runtime_error</span><span class="special">(</span><span class="string">"translated exception"</span><span class="special">))</span>
<span class="special">]</span>
</pre>
</div>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.object"></a><a class="link" href="composite.html#phoenix.composite.object" title="Object">Object</a>
</h3></div></div></div>
<p>
The Object module deals with object construction, destruction and conversion.
The module provides <span class="emphasis"><em>"lazy"</em></span> versions of C++'s
object constructor, <code class="computeroutput"><span class="keyword">new</span></code>, <code class="computeroutput"><span class="keyword">delete</span></code>, <code class="computeroutput"><span class="keyword">static_cast</span></code>,
<code class="computeroutput"><span class="keyword">dynamic_cast</span></code>, <code class="computeroutput"><span class="keyword">const_cast</span></code> and <code class="computeroutput"><span class="keyword">reinterpret_cast</span></code>.
</p>
<a name="phoenix.composite.object.construction"></a><h3>
<a name="id777481"></a>
<a class="link" href="composite.html#phoenix.composite.object.construction">Construction</a>
</h3>
<p>
<span class="bold"><strong><span class="emphasis"><em>Lazy constructors...</em></span></strong></span>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="identifier">construct</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Lazily construct an object from an arbitrary set of arguments:
</p>
<pre class="programlisting"><span class="identifier">construct</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">ctor_arg1</span><span class="special">,</span> <span class="identifier">ctor_arg2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">ctor_argN</span><span class="special">);</span>
</pre>
<p>
where the given parameters are the parameters to the contructor of the object
of type T (This implies, that type T is expected to have a constructor with
a corresponding set of parameter types.).
</p>
<p>
Example:
</p>
<pre class="programlisting"><span class="identifier">construct</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">>(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span><span class="special">)</span>
</pre>
<p>
Constructs a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> from <code class="computeroutput"><span class="identifier">arg1</span></code>
and <code class="computeroutput"><span class="identifier">arg2</span></code>.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
The maximum number of actual parameters is limited by the preprocessor
constant PHOENIX_COMPOSITE_LIMIT. Note though, that this limit should not
be greater than PHOENIX_LIMIT. By default, <code class="computeroutput"><span class="identifier">PHOENIX_COMPOSITE_LIMIT</span></code>
is set to <code class="computeroutput"><span class="identifier">PHOENIX_LIMIT</span></code>
(See <a class="link" href="actors.html" title="Actors">Actors</a>).
</p></td></tr>
</table></div>
<a name="phoenix.composite.object.new"></a><h3>
<a name="id777797"></a>
<a class="link" href="composite.html#phoenix.composite.object.new">New</a>
</h3>
<p>
<span class="bold"><strong><span class="emphasis"><em>Lazy new...</em></span></strong></span>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">new</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Lazily construct an object, on the heap, from an arbitrary set of arguments:
</p>
<pre class="programlisting"><span class="identifier">new_</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">ctor_arg1</span><span class="special">,</span> <span class="identifier">ctor_arg2</span><span class="special">,</span> <span class="special">...,</span> <span class="identifier">ctor_argN</span><span class="special">);</span>
</pre>
<p>
where the given parameters are the parameters to the contructor of the object
of type T (This implies, that type T is expected to have a constructor with
a corresponding set of parameter types.).
</p>
<p>
Example:
</p>
<pre class="programlisting"><span class="identifier">new_</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">>(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="comment">// note the spelling of new_ (with trailing underscore)
</span></pre>
<p>
Creates a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> from <code class="computeroutput"><span class="identifier">arg1</span></code>
and <code class="computeroutput"><span class="identifier">arg2</span></code> on the heap.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Again, the maximum number of actual parameters is limited by the preprocessor
constant PHOENIX_COMPOSITE_LIMIT. See the note above.
</p></td></tr>
</table></div>
<a name="phoenix.composite.object.delete"></a><h3>
<a name="id778089"></a>
<a class="link" href="composite.html#phoenix.composite.object.delete">Delete</a>
</h3>
<p>
<span class="bold"><strong><span class="emphasis"><em>Lazy delete...</em></span></strong></span>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">delete</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Lazily delete an object, from the heap:
</p>
<pre class="programlisting"><span class="identifier">delete_</span><span class="special">(</span><span class="identifier">arg</span><span class="special">);</span>
</pre>
<p>
where arg is assumed to be a pointer to an object.
</p>
<p>
Example:
</p>
<pre class="programlisting"><span class="identifier">delete_</span><span class="special"><</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">>(</span><span class="identifier">arg1</span><span class="special">)</span> <span class="comment">// note the spelling of delete_ (with trailing underscore)
</span></pre>
<a name="phoenix.composite.object.casts"></a><h3>
<a name="id778280"></a>
<a class="link" href="composite.html#phoenix.composite.object.casts">Casts</a>
</h3>
<p>
<span class="bold"><strong><span class="emphasis"><em>Lazy casts...</em></span></strong></span>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">static_cast</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">dynamic_cast</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">const_cast</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
<span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">object</span><span class="special">/</span><span class="keyword">reinterpret_cast</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
The set of lazy C++ cast template functions provide a way of lazily casting
an object of a certain type to another type. The syntax resembles the well
known C++ casts. Take note however that the lazy versions have a trailing
underscore.
</p>
<pre class="programlisting"><span class="identifier">static_cast_</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">lambda_expression</span><span class="special">)</span>
<span class="identifier">dynamic_cast_</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">lambda_expression</span><span class="special">)</span>
<span class="identifier">const_cast_</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">lambda_expression</span><span class="special">)</span>
<span class="identifier">reinterpret_cast_</span><span class="special"><</span><span class="identifier">T</span><span class="special">>(</span><span class="identifier">lambda_expression</span><span class="special">)</span>
</pre>
<p>
Example:
</p>
<pre class="programlisting"><span class="identifier">static_cast_</span><span class="special"><</span><span class="identifier">Base</span><span class="special">*>(&</span><span class="identifier">arg1</span><span class="special">)</span>
</pre>
<p>
Static-casts the address of <code class="computeroutput"><span class="identifier">arg1</span></code>
to a <code class="computeroutput"><span class="identifier">Base</span><span class="special">*</span></code>.
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.scope"></a><a class="link" href="composite.html#phoenix.composite.scope" title="Scope">Scope</a>
</h3></div></div></div>
<p>
Up until now, the most basic ingredient is missing: creation of and access
to local variables in the stack. When recursion comes into play, you will
soon realize the need to have true local variables. It may seem that we do
not need this at all since an unnamed lambda function cannot call itself
anyway; at least not directly. With some sort of arrangement, situations
will arise where a lambda function becomes recursive. A typical situation
occurs when we store a lambda function in a <a href="http://www.boost.org/libs/function" target="_top">Boost.Function</a>,
essentially naming the unnamed lambda.
</p>
<p>
There will also be situations where a lambda function gets passed as an argument
to another function. This is a more common situation. In this case, the lambda
function assumes a new scope; new arguments and possibly new local variables.
</p>
<p>
This section deals with local variables and nested lambda scopes.
</p>
<a name="phoenix.composite.scope.local_variables"></a><h3>
<a name="id778838"></a>
<a class="link" href="composite.html#phoenix.composite.scope.local_variables">Local Variables</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">scope</span><span class="special">/</span><span class="identifier">local_variable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
We use an instance of:
</p>
<pre class="programlisting"><span class="identifier">actor</span><span class="special"><</span><span class="identifier">local_variable</span><span class="special"><</span><span class="identifier">Key</span><span class="special">></span> <span class="special">></span>
</pre>
<p>
to represent a local variable. The local variable acts as an imaginary data-bin
where a local, stack based data will be placed. <code class="computeroutput"><span class="identifier">Key</span></code>
is an arbitrary type that is used to identify the local variable. Example:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">size_key</span><span class="special">;</span>
<span class="identifier">actor</span><span class="special"><</span><span class="identifier">local_variable</span><span class="special"><</span><span class="identifier">size_key</span><span class="special">></span> <span class="special">></span> <span class="identifier">size</span><span class="special">;</span>
</pre>
<a name="phoenix.composite.scope.predefined_local_variables"></a><h3>
<a name="id779063"></a>
<a class="link" href="composite.html#phoenix.composite.scope.predefined_local_variables">Predefined
Local Variables</a>
</h3>
<p>
There are a few predefined instances of <code class="computeroutput"><span class="identifier">actor</span><span class="special"><</span><span class="identifier">local_variable</span><span class="special"><</span><span class="identifier">Key</span><span class="special">></span> <span class="special">></span></code>
named <code class="computeroutput"><span class="identifier">_a</span></code>..<code class="computeroutput"><span class="identifier">_z</span></code>
that you can already use. To make use of them, simply use the <code class="computeroutput"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">local_names</span></code>:
</p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">local_names</span><span class="special">;</span>
</pre>
<a name="phoenix.composite.scope.let"></a><h3>
<a name="id779228"></a>
<a class="link" href="composite.html#phoenix.composite.scope.let">let</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">scope</span><span class="special">/</span><span class="identifier">let</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
You declare local variables using the syntax:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span><span class="identifier">local</span><span class="special">-</span><span class="identifier">declarations</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">let</span><span class="special">-</span><span class="identifier">body</span>
<span class="special">]</span>
</pre>
<p>
<code class="computeroutput"><span class="identifier">let</span></code> allows 1..N local variable
declarations (where N == <code class="computeroutput"><span class="identifier">PHOENIX_LOCAL_LIMIT</span></code>).
Each declaration follows the form:
</p>
<pre class="programlisting"><span class="identifier">local</span><span class="special">-</span><span class="identifier">id</span> <span class="special">=</span> <span class="identifier">lambda</span><span class="special">-</span><span class="identifier">expression</span>
</pre>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
You can set <code class="computeroutput"><span class="identifier">PHOENIX_LOCAL_LIMIT</span></code>,
the predefined maximum local variable declarations in a let expression.
By default, <code class="computeroutput"><span class="identifier">PHOENIX_LOCAL_LIMIT</span></code>
is set to <code class="computeroutput"><span class="identifier">PHOENIX_LIMIT</span></code>.
</p></td></tr>
</table></div>
<p>
Example:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="number">123</span><span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="number">456</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">_a</span> <span class="special">+</span> <span class="identifier">_b</span>
<span class="special">]</span>
</pre>
<a name="phoenix.composite.scope.reference_preservation"></a><h3>
<a name="id779579"></a>
<a class="link" href="composite.html#phoenix.composite.scope.reference_preservation">Reference
Preservation</a>
</h3>
<p>
The type of the local variable assumes the type of the lambda- expression.
Type deduction is reference preserving. For example:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="number">456</span><span class="special">)</span>
</pre>
<p>
<code class="computeroutput"><span class="identifier">_a</span></code> assumes the type of <code class="computeroutput"><span class="identifier">arg1</span></code>: a reference to an argument, while
<code class="computeroutput"><span class="identifier">_b</span></code> has type <code class="computeroutput"><span class="keyword">int</span></code>.
</p>
<p>
Consider this:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">let</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="identifier">arg1</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="special">--</span><span class="identifier">_a</span> <span class="special"><<</span> <span class="char">' '</span>
<span class="special">]</span>
<span class="special">(</span><span class="identifier">i</span><span class="special">);</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">i</span> <span class="special"><<</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
the output of above is : 0 0
</p>
<p>
While with this:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">1</span><span class="special">;</span>
<span class="identifier">let</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="identifier">val</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">))</span>
<span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="special">--</span><span class="identifier">_a</span> <span class="special"><<</span> <span class="char">' '</span>
<span class="special">]</span>
<span class="special">(</span><span class="identifier">i</span><span class="special">);</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">i</span> <span class="special"><<</span> <span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
the output is : 0 1
</p>
<p>
Reference preservation is necessary because we need to have L-value access
to outer lambda-scopes (especially the arguments). <code class="computeroutput"><span class="identifier">arg</span></code>s
and <code class="computeroutput"><span class="identifier">ref</span></code>s are L-values. <code class="computeroutput"><span class="identifier">val</span></code>s are R-values.
</p>
<a name="phoenix.composite.scope.visibility"></a><h3>
<a name="id780063"></a>
<a class="link" href="composite.html#phoenix.composite.scope.visibility">Visibility</a>
</h3>
<p>
The scope and lifetimes of the local variables is limited within the let-body.
<code class="computeroutput"><span class="identifier">let</span></code> blocks can be nested.
A local variable may hide an outer local variable. For example:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span><span class="identifier">_x</span> <span class="special">=</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">_y</span> <span class="special">=</span> <span class="string">", World"</span><span class="special">)</span>
<span class="special">[</span>
<span class="comment">// _x here is an int: 1
</span>
<span class="identifier">let</span><span class="special">(</span><span class="identifier">_x</span> <span class="special">=</span> <span class="string">"Hello"</span><span class="special">)</span> <span class="comment">// hides the outer _x
</span> <span class="special">[</span>
<span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">_x</span> <span class="special"><<</span> <span class="identifier">_y</span> <span class="comment">// prints "Hello, World"
</span> <span class="special">]</span>
<span class="special">]</span>
</pre>
<p>
The RHS (right hand side lambda-expression) of each local-declaration cannot
refer to any LHS local-id. At this point, the local-ids are not in scope
yet; they will only be in scope in the let-body. The code below is in error:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span>
<span class="identifier">_a</span> <span class="special">=</span> <span class="number">1</span>
<span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="identifier">_a</span> <span class="comment">// Error: _a is not in scope yet
</span><span class="special">)</span>
<span class="special">[</span>
<span class="comment">// _a and _b's scope starts here
</span> <span class="comment">/*. body .*/</span>
<span class="special">]</span>
</pre>
<p>
However, if an outer let scope is available, this will be searched. Since
the scope of the RHS of a local-declaration is the outer scope enclosing
the let, the RHS of a local-declaration can refer to a local variable of
an outer scope:
</p>
<pre class="programlisting"><span class="identifier">let</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="number">1</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">let</span><span class="special">(</span>
<span class="identifier">_a</span> <span class="special">=</span> <span class="number">1</span>
<span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="identifier">_a</span> <span class="comment">// Ok. _a refers to the outer _a
</span> <span class="special">)</span>
<span class="special">[</span>
<span class="comment">/*. body .*/</span>
<span class="special">]</span>
<span class="special">]</span>
</pre>
<a name="phoenix.composite.scope.lambda"></a><h3>
<a name="id780472"></a>
<a class="link" href="composite.html#phoenix.composite.scope.lambda">lambda</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">scope</span><span class="special">/</span><span class="identifier">lambda</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
A lot of times, you'd want to write a lazy function that accepts one or more
functions (higher order functions). STL algorithms come to mind, for example.
Consider a lazy version of <code class="computeroutput"><span class="identifier">stl</span><span class="special">::</span><span class="identifier">for_each</span></code>:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">for_each_impl</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">result</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">F</span><span class="special">></span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">C</span><span class="special">&</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">F</span> <span class="identifier">f</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">c</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">c</span><span class="special">.</span><span class="identifier">end</span><span class="special">(),</span> <span class="identifier">f</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="identifier">function</span><span class="special"><</span><span class="identifier">for_each_impl</span><span class="special">></span> <span class="keyword">const</span> <span class="identifier">for_each</span> <span class="special">=</span> <span class="identifier">for_each_impl</span><span class="special">();</span>
</pre>
<p>
Notice that the function accepts another function, <code class="computeroutput"><span class="identifier">f</span></code>
as an argument. The scope of this function, <code class="computeroutput"><span class="identifier">f</span></code>,
is limited within the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>. When <code class="computeroutput"><span class="identifier">f</span></code>
is called inside <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span></code>, it exists in a new scope, along
with new arguments and, possibly, local variables. This new scope is not
at all related to the outer scopes beyond the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>.
</p>
<p>
Simple syntax:
</p>
<pre class="programlisting"><span class="identifier">lambda</span>
<span class="special">[</span>
<span class="identifier">lambda</span><span class="special">-</span><span class="identifier">body</span>
<span class="special">]</span>
</pre>
<p>
Like <code class="computeroutput"><span class="identifier">let</span></code>, local variables
may be declared, allowing 1..N local variable declarations (where N == <code class="computeroutput"><span class="identifier">PHOENIX_LOCAL_LIMIT</span></code>):
</p>
<pre class="programlisting"><span class="identifier">lambda</span><span class="special">(</span><span class="identifier">local</span><span class="special">-</span><span class="identifier">declarations</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">lambda</span><span class="special">-</span><span class="identifier">body</span>
<span class="special">]</span>
</pre>
<p>
The same restrictions apply with regard to scope and visibility. The RHS
(right hand side lambda-expression) of each local-declaration cannot refer
to any LHS local-id. The local-ids are not in scope yet; they will be in
scope only in the lambda-body:
</p>
<pre class="programlisting"><span class="identifier">lambda</span><span class="special">(</span>
<span class="identifier">_a</span> <span class="special">=</span> <span class="number">1</span>
<span class="special">,</span> <span class="identifier">_b</span> <span class="special">=</span> <span class="identifier">_a</span> <span class="comment">// Error: _a is not in scope yet
</span><span class="special">)</span>
</pre>
<p>
See <a class="link" href="composite.html#phoenix.composite.scope.visibility"><code class="computeroutput"><span class="identifier">let</span></code>
Visibility</a> above for more information.
</p>
<p>
Example: Using our lazy <code class="computeroutput"><span class="identifier">for_each</span></code>
let's print all the elements in a container:
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">lambda</span><span class="special">[</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">arg1</span><span class="special">])</span>
</pre>
<p>
As far as the arguments are concerned (arg1..argN), the scope in which the
lambda-body exists is totally new. The left <code class="computeroutput"><span class="identifier">arg1</span></code>
refers to the argument passed to <code class="computeroutput"><span class="identifier">for_each</span></code>
(a container). The right <code class="computeroutput"><span class="identifier">arg1</span></code>
refers to the argument passed by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">for_each</span></code>
when we finally get to call <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> in our <code class="computeroutput"><span class="identifier">for_each_impl</span></code>
above (a container element).
</p>
<p>
Yet, we may wish to get information from outer scopes. While we do not have
access to arguments in outer scopes, what we still have is access to local
variables from outer scopes. We may only be able to pass argument related
information from outer <code class="computeroutput"><span class="identifier">lambda</span></code>
scopes through the local variables.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
This is a crucial difference between <code class="computeroutput"><span class="identifier">let</span></code>
and <code class="computeroutput"><span class="identifier">lambda</span></code>: <code class="computeroutput"><span class="identifier">let</span></code> does not introduce new arguments;
<code class="computeroutput"><span class="identifier">lambda</span></code> does.
</p></td></tr>
</table></div>
<p>
Another example: Using our lazy <code class="computeroutput"><span class="identifier">for_each</span></code>,
and a lazy <code class="computeroutput"><span class="identifier">push_back</span></code>:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">push_back_impl</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">struct</span> <span class="identifier">result</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="keyword">void</span> <span class="identifier">type</span><span class="special">;</span>
<span class="special">};</span>
<span class="keyword">template</span> <span class="special"><</span><span class="keyword">typename</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">></span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">C</span><span class="special">&</span> <span class="identifier">c</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">c</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">x</span><span class="special">);</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="identifier">function</span><span class="special"><</span><span class="identifier">push_back_impl</span><span class="special">></span> <span class="keyword">const</span> <span class="identifier">push_back</span> <span class="special">=</span> <span class="identifier">push_back_impl</span><span class="special">();</span>
</pre>
<p>
write a lambda expression that accepts:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
a 2-dimensional container (e.g. <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span><span class="identifier">vector</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span> <span class="special">></span></code>)
</li>
<li class="listitem">
a container element (e.g. <code class="computeroutput"><span class="keyword">int</span></code>)
</li>
</ol></div>
<p>
and pushes-back the element to each of the <code class="computeroutput"><span class="identifier">vector</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code>.
</p>
<p>
Solution:
</p>
<pre class="programlisting"><span class="identifier">for_each</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span>
<span class="identifier">lambda</span><span class="special">(</span><span class="identifier">_a</span> <span class="special">=</span> <span class="identifier">arg2</span><span class="special">)</span>
<span class="special">[</span>
<span class="identifier">push_back</span><span class="special">(</span><span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">_a</span><span class="special">)</span>
<span class="special">]</span>
<span class="special">)</span>
</pre>
<p>
Since we do not have access to the arguments of the outer scopes beyond the
lambda-body, we introduce a local variable <code class="computeroutput"><span class="identifier">_a</span></code>
that captures the second outer argument: <code class="computeroutput"><span class="identifier">arg2</span></code>.
Hence: _a = arg2. This local variable is visible inside the lambda scope.
</p>
<p>
(See <a href="../../../example/users_manual/lambda.cpp" target="_top">lambda.cpp</a>)
</p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="phoenix.composite.bind"></a><a class="link" href="composite.html#phoenix.composite.bind" title="Bind">Bind</a>
</h3></div></div></div>
<p>
<span class="emphasis"><em>Binding</em></span> is the act of tying together a function to some
arguments for deferred (lazy) evaluation. Named <a class="link" href="composite.html#phoenix.composite.function" title="Function">Lazy
functions</a> require a bit of typing. Unlike (unnamed) lambda expressions,
we need to write a functor somewhere offline, detached from the call site.
If you wish to transform a plain function, member function or member variable
to a lambda expression, <code class="computeroutput"><span class="identifier">bind</span></code>
is your friend.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
Take note that binders are monomorphic. Rather than binding functions,
the preferred way is to write true generic and polymorphic <a class="link" href="composite.html#phoenix.composite.function" title="Function">lazy-functions</a>.
However, since most of the time we are dealing with adaptation of exisiting
code, binders get the job done faster.
</p></td></tr>
</table></div>
<p>
There is a set of overloaded <code class="computeroutput"><span class="identifier">bind</span></code>
template functions. Each <code class="computeroutput"><span class="identifier">bind</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
function generates a suitable binder object, a <a class="link" href="composite.html" title="Composite">composite</a>.
</p>
<a name="phoenix.composite.bind.binding_functions"></a><h3>
<a name="id782121"></a>
<a class="link" href="composite.html#phoenix.composite.bind.binding_functions">Binding Functions</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">bind</span><span class="special">/</span><span class="identifier">bind_function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Example, given a function <code class="computeroutput"><span class="identifier">foo</span></code>:
</p>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">n</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special"><<</span> <span class="identifier">n</span> <span class="special"><<</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
Here's how the function <code class="computeroutput"><span class="identifier">foo</span></code>
may be bound:
</p>
<pre class="programlisting"><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)</span>
</pre>
<p>
This is now a full-fledged <a class="link" href="composite.html" title="Composite">composite</a>
that can finally be evaluated by another function call invocation. A second
function call will invoke the actual <code class="computeroutput"><span class="identifier">foo</span></code>
function. Example:
</p>
<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">4</span><span class="special">;</span>
<span class="identifier">bind</span><span class="special">(&</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)(</span><span class="identifier">i</span><span class="special">);</span>
</pre>
<p>
will print out "4".
</p>
<a name="phoenix.composite.bind.binding_member_functions"></a><h3>
<a name="id782474"></a>
<a class="link" href="composite.html#phoenix.composite.bind.binding_member_functions">Binding Member
Functions</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">bind</span><span class="special">/</span><span class="identifier">bind_member_function</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Binding member functions can be done similarly. A bound member function takes
in a pointer or reference to an object as the first argument. For instance,
given:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xyz</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
<code class="computeroutput"><span class="identifier">xyz</span></code>'s <code class="computeroutput"><span class="identifier">foo</span></code>
member function can be bound as:
</p>
<pre class="programlisting"><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">obj</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)</span> <span class="comment">// obj is an xyz object
</span></pre>
<p>
Take note that a lazy-member functions expects the first argument to be a
pointer or reference to an object. Both the object (reference or pointer)
and the arguments can be lazily bound. Examples:
</p>
<pre class="programlisting"><span class="identifier">xyz</span> <span class="identifier">obj</span><span class="special">;</span>
<span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">,</span> <span class="identifier">arg2</span><span class="special">)</span> <span class="comment">// arg1.foo(arg2)
</span><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">obj</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)</span> <span class="comment">// obj.foo(arg1)
</span><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">obj</span><span class="special">,</span> <span class="number">100</span><span class="special">)</span> <span class="comment">// obj.foo(100)
</span></pre>
<a name="phoenix.composite.bind.binding_member_variables"></a><h3>
<a name="id782905"></a>
<a class="link" href="composite.html#phoenix.composite.bind.binding_member_variables">Binding Member
Variables</a>
</h3>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">home</span><span class="special">/</span><span class="identifier">phoenix</span><span class="special">/</span><span class="identifier">bind</span><span class="special">/</span><span class="identifier">bind_member_variable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
</pre>
<p>
Member variables can also be bound much like member functions. Member variables
are not functions. Yet, like the <a class="link" href="primitives.html#phoenix.primitives.references" title="References"><code class="computeroutput"><span class="identifier">ref</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code></a> that acts like a nullary function
returning a reference to the data, member variables, when bound, act like
a unary function, taking in a pointer or reference to an object as its argument
and returning a reference to the bound member variable. For instance, given:
</p>
<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xyz</span>
<span class="special">{</span>
<span class="keyword">int</span> <span class="identifier">v</span><span class="special">;</span>
<span class="special">};</span>
</pre>
<p>
<code class="computeroutput"><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">v</span></code> can be bound as:
</p>
<pre class="programlisting"><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">obj</span><span class="special">)</span> <span class="comment">// obj is an xyz object
</span></pre>
<p>
As noted, just like the bound member function, a bound member variable also
expects the first (and only) argument to be a pointer or reference to an
object. The object (reference or pointer) can be lazily bound. Examples:
</p>
<pre class="programlisting"><span class="identifier">xyz</span> <span class="identifier">obj</span><span class="special">;</span>
<span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)</span> <span class="comment">// arg1.v
</span><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">obj</span><span class="special">)</span> <span class="comment">// obj.v
</span><span class="identifier">bind</span><span class="special">(&</span><span class="identifier">xyz</span><span class="special">::</span><span class="identifier">v</span><span class="special">,</span> <span class="identifier">arg1</span><span class="special">)(</span><span class="identifier">obj</span><span class="special">)</span> <span class="special">=</span> <span class="number">4</span> <span class="comment">// obj.v = 4
</span></pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2005 Joel
de Guzman, Dan Marsden<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="primitives.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="container.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
