Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.boost.org/doc/libs/release/libs/phoenix/doc/html/phoenix/modules/core/arguments.html below:

#include <boost/phoenix/core/argument.hpp>

We use an instance of:

expression::argument<N>::type

to represent the Nth function argument. The argument placeholder acts as an imaginary data-bin where a function argument will be placed.

There are a few predefined instances of expression::argument<N>::type named arg1..argN, and its BLL counterpart _1.._N. (where N is a predefined maximum).

Here are some sample preset definitions of arg1..argN

namespace placeholders
{
    expression::argument<1>::type const arg1 = {};
    expression::argument<2>::type const arg2 = {};
    expression::argument<3>::type const arg3 = {};
}

and its BLL _1.._N style counterparts:

namespace placeholders
{
    expression::argument<1>::type const _1 = {};
    expression::argument<2>::type const _2 = {};
    expression::argument<3>::type const _3 = {};
}

You can set BOOST_PHOENIX_ARG_LIMIT, the predefined maximum placeholder index. By default, BOOST_PHOENIX_ARG_LIMIT is set to BOOST_PHOENIX_LIMIT (See Actor).

When appropriate, you can define your own argument names. For example:

expression::argument<1>::type x; 

x may now be used as a parameter to a lazy function:

add(x, 6)

which is equivalent to:

add(arg1, 6)

An argument, when evaluated, selects the Nth argument from the those passed in by the client.

For example:

char        c = 'A';
int         i = 123;
const char* s = "Hello World";

cout << arg1(c) << endl;        
cout << arg1(i, s) << endl;     
cout << arg2(i, s) << endl;     

will print out:

A
123
Hello World

In C and C++, a function can have extra arguments that are not at all used by the function body itself. These extra arguments are simply ignored.

Phoenix also allows extra arguments to be passed. For example, recall our original add function:

add(arg1, arg2)

We know now that partially applying this function results to a function that expects 2 arguments. However, the library is a bit more lenient and allows the caller to supply more arguments than is actually required. Thus, add actually allows 2 or more arguments. For instance, with:

add(arg1, arg2)(x, y, z)

the third argument z is ignored. Taking this further, in-between arguments are also ignored. Example:

add(arg1, arg5)(a, b, c, d, e)

Here, arguments b, c, and d are ignored. The function add takes in the first argument (arg1) and the fifth argument (arg5).

There are a few reasons why enforcing strict arity is not desirable. A case in point is the callback function. Typical callback functions provide more information than is actually needed. Lambda functions are often used as callbacks.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4