| Home | Libraries | People | FAQ | More

## Function template public_function

boost::contract::public_function — Program contracts for void virtual public functions that do not override.

## Synopsis

    // In header: <boost/contract/public_function.hpp>

    template<typename Class>
      specify_precondition_old_postcondition_except
      public_function(virtual_ * v, Class * obj);

## Description

This is used to specify preconditions, postconditions, exception guarantees, old value copies at body, and check class invariants for public functions that are virtual, do not override, and return `void:`

    class u {
        friend class boost::contract::access;

        void invariant() const { // Optional (as for static and volatile).
            BOOST_CONTRACT_ASSERT(...);
            ...
        }

    public:
        void f(..., boost::contract::virtual_* v = 0) {
            boost::contract::old_ptr<old_type> old_var;
            boost::contract::check c = boost::contract::public_function(v, this)
                .precondition([&] { // Optional.
                    BOOST_CONTRACT_ASSERT(...);
                    ...
                })
                .old([&] { // Optional.
                    old_var = BOOST_CONTRACT_OLDOF(v, old_expr);
                    ...
                })
                .postcondition([&] { // Optional.
                    BOOST_CONTRACT_ASSERT(...);
                    ...
                })
                .except([&] { // Optional.
                    BOOST_CONTRACT_ASSERT(...);
                    ...
                })
            ;

            ... // Function body.
        }

        ...
    };

A virtual public function should always call ``boost::contract::public_function`` otherwise this library will not be able to correctly use it for subcontracting.

See Also: Virtual Public Functions

Parameters: |
`v` | The trailing parameter of type ``boost::contract::virtual_```*` and default value `0` from the enclosing virtual public function.
`obj` | The object `this` from the scope of the enclosing virtual public function declaring the contract. This object might be mutable, `const`, `volatile`, or `const volatile` depending on the cv-qualifier of the enclosing function (volatile public functions will check volatile class invariants, see Volatile Public Functions).
Template Parameters: |
`Class` | The type of the class containing the virtual public function declaring the contract. (Usually this template parameter is automatically deduced by C++ and it does not need to be explicitly specified by programmers.)
Returns: | The result of this function must be assigned to a variable of type `boost::contract::check` declared explicitly (i.e., without using C++11 `auto` declarations) and locally just before the code of the public function body (otherwise this library will generate a run-time error, see `BOOST_CONTRACT_ON_MISSING_CHECK_DECL`).