| Home | Libraries | People | FAQ | More

## Macro BOOST_SCOPE_EXIT_ALL

BOOST_SCOPE_EXIT_ALL — This macro declares a scope exit that captures all variables in scope (C++11 only).

## Synopsis

    // In header: <boost/scope_exit.hpp>

    BOOST_SCOPE_EXIT_ALL(capture_list)

## Description

This macro accepts a capture list starting with either `&` or `=` to capture all variables in scope by reference or value respectively (following the same syntax of C++11 lambdas). A part from that, this macro works like `BOOST_SCOPE_EXIT` (see `BOOST_SCOPE_EXIT` for more information):

    { // Some local scope.
        ...
        BOOST_SCOPE_EXIT_ALL(capture_list) { // C++11 only.
            ... // Body code.
        }; // Use `;` instead of `BOOST_SCOPE_EXIT_END` (C++11 only).
        ...
    }

Note how the end of the scope exit body declared by this macro must be marked by a semi-column `;` (and not by `BOOST_SCOPE_EXIT_END`).

Warning: This macro is only available on C++11 compilers (specifically, on C++11 compilers that do not define the Boost.Config `BOOST_NO_CXX11_LAMBDAS` macro). It is not defined on non-C++11 compilers so its use on non-C++11 compilers will generate a compiler error.

Parameters:

`capture_list`

On compilers that support variadic macros (see also Boost.Config `BOOST_NO_CXX11_VARIADIC_MACROS`), the capture list syntax is defined by the following grammar:

    capture_list:
            capture_tuple | capture_sequence
    capture_tuple:
            {& | =} [, capture, capture, ...]
    capture_sequence:
            {(&) | (=)} [(capture) (capture) ...]
    capture:
            [&]variable | this_

On compilers that do not support variadic macros, `capture_tuple` cannot be used:

    capture_list:
            void | capture_sequence

Furthermore, on C++11 compilers that support the use of `typename` outside templates, also `this` can be used to capture the object at member function scope:

    capture:
            [&]variable | this_ | this

(Lexical conventions: `token1 | token2` means either `token1` or `token2`; `[token]` means either `token` or nothing; `{expression}` means the token resulting from the expression.)

Note that on compilers with variadic macro support (which should be all C++11 compilers), the capture list can be specified as a comma-separated list. On all compilers, the same macro `BOOST_SCOPE_EXIT_ALL` also allows to specify the capture list as a Boost.Preprocessor sequence.

The capture list must always contain at least the leading `&` or `=` so it can never be `void` (`BOOST_SCOPE_EXIT(void)` should be used to program scope exits with an empty capture list).

In general, the special macro `BOOST_SCOPE_EXIT_ALL_ID` must be used instead of `BOOST_SCOPE_EXIT_ALL` when it is necessary to expand multiple scope exit declarations on the same line.

Warning: This macro capture list follows the exact same syntax of C++11 lambda captures which is unfortunately different from the syntax of `BOOST_SCOPE_EXIT` captures (unless programmers define the `BOOST_SCOPE_EXIT_CONFIG_USE_LAMBDAS` macro). For example, like C++11 lambda functions, `BOOST_SCOPE_EXIT_ALL` requires to capture data members by capturing the object `this` while `BOOST_SCOPE_EXIT` allows to capture data members directly and without capturing the object.

Warning: The implementation executes the scope exit body within a destructor thus the scope exit body must never throw in order to comply with STL exception safety requirements.

Note: This macro can always be used also within templates (so there is no need for a `BOOST_SCOPE_EXIT_ALL_TPL` macro).

See: Tutorial section, No Variadic Macros section, `BOOST_SCOPE_EXIT`, `BOOST_SCOPE_EXIT_ALL_ID`.