###  | # Boost.Python ## Header <boost/python/implicit.hpp>

## Contents

Introduction
Functions
  Function Template `implicitly_convertible`
Example

## Introduction

`implicitly_convertible` allows Boost.Python to implicitly take advantage of a C++ implicit or explicit conversion when matching Python objects to C++ argument types.

## Functions

### Function template `implicitly_convertible`

    template <class Source, class Target>
    void implicitly_convertible();

`implicitly_convertible` template parameters
Parameter | Description
--- | ---
`Source` | The source type of the implicit conversion
`Target` | The target type of the implicit conversion

Requires: The declaration `Target t(s);`, where `s` is of type `Source`, is valid.
Effects: registers an rvalue `from_python` converter to `Target` which can succeed for any `PyObject* p` iff there exists any registered converter which can produce `Source` rvalues
Rationale: C++ users expect to be able to take advantage of the same sort of interoperability in Python as they do in C++.

## Example

### C++ module definition

    #include <boost/python/class.hpp>
    #include <boost/python/implicit.hpp>
    #include <boost/python/module.hpp>

    using namespace boost::python;

    struct X
    {
        X(int x) : v(x) {}
        operator int() const { return v; }
        int v;
    };

    int x_value(X const& x)
    {
        return x.v;
    }

    X make_x(int n) { return X(n); }

    BOOST_PYTHON_MODULE(implicit_ext)
    {
        def("x_value", x_value);
        def("make_x", make_x);

        class_<X>("X",
            init<int>())
            ;

        implicitly_convertible<X,int>();
        implicitly_convertible<int,X>();
    }

### Python code

    >>> from implicit_ext import *
    >>> x_value(X(42))
    42
    >>> x_value(42)
    42
    >>> x = make_x(X(42))
    >>> x_value(x)
    42

Revised 13 November, 2002

© Copyright Dave Abrahams 2002.