Boost.Python包装（成员）函数指针。不幸的是，C ++函数指针没有默认参数信息。使用默认参数获取函数f：

int f（int，double = 3.14，char const * =“hello”）;

但是指向函数f的指针类型没有关于其默认参数的信息：

int(*g)(int,double,char const*) = f;    // 默认值丢失

当我们将此函数指针传递给def函数时，无法检索默认参数：

def("f", f);                            // defaults lost!

因此，在包装C ++代码时，我们不得不求助于上一节中概述的手动换行，或者编写精简包装器：
//写“薄包装”

// write "thin wrappers"
int f1(int x) { return f(x); }
int f2(int x, double y) { return f(x,y); }

/*...*/

    // in module init
    def("f", f);  // all arguments
    def("f", f2); // two arguments
    def("f", f1); // one argument

当你想要包装函数（或成员函数）时：

• 有默认参数，或
• 重载了一个共同的初始参数序列

BOOST_PYTHON_FUNCTION_OVERLOADS
Boost.Python现在有办法让它变得更容易。例如，给定一个函数：

int foo（int a，char b = 1，unsigned c = 2，double d = 3）
{
    /*...*/
}

宏调用：

BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 1, 4)

将自动为我们创建薄包装器。这个宏将创建一个可以传递给def（...）的类foo_overloads。第三个和第四个宏参数分别是最小参数和最大参数。在我们的foo函数中，参数的最小数量为1，参数的最大数量为4. def（...）函数会自动为我们添加所有foo变体：

def("foo", foo, foo_overloads());

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS
这里的物体，那里的物体，到处都有物体。比其他任何事情更频繁，我们需要将类的成员函数暴露给Python。然后，
当默认参数或具有共同初始参数序列的重载发挥作用时，我们会遇到与之前相同的不便。提供另一个宏来使这变得轻而易举。

与BOOST_PYTHON_FUNCTION_OVERLOADS类似，BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS可用于自动创建包装成员函数的精简包装器。
我们举个例子：

struct george
{
    void
    wack_em(int a, int b = 0, char c = 'x')
    {
        /*...*/
    }
};

宏调用：

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(george_overloads, wack_em, 1, 3)

将为george的wack_em成员函数生成一组薄包装器，接受最少1个参数和最多3个参数（例如,第三和第四个宏观论点）。薄包装器都包含在一个名为george_overloads的类中，然后可以用作def（...）的参数：

.def("wack_em", &george::wack_em, george_overloads());

有关详细信息，请参阅重载参考。

init和optional
同样为类构造者提供了类似的设施，
使用默认参数或一系列重载。还记得init <...>吗？例如，给定一个带有构造函数的类X：

struct X
{
    X(int a, char b = 'D', std::string c = "constructor", double d = 0.0);
    /*...*/
}

您可以轻松地将此构造函数一次性添加到Boost.Python：

.def(init<int, optional<char, std::string, double> >())

注意使用init <...>和可选<...>来表示默认值（可选参数）。

自动重载
在前一节中已经提到BOOST_PYTHON_FUNCTION_OVERLOADS和BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS也可以用于具有共同初始参数序列的重载函数和成员函数。
这是一个例子：

void foo()
{
   /*...*/
}

void foo(bool a)
{
   /*...*/
}

void foo(bool a, int b)
{
   /*...*/
}

void foo(bool a, int b, char c)
{
   /*...*/
}

与上一节一样，我们可以一次性为这些重载函数生成精简包装：

BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, 0, 3)

然后...

.def("foo", (void(*)(bool, int, char))0, foo_overloads());

请注意，我们现在有一个情况，我们最少有零（0）个参数和最多3个参数。

手动包装
然而，重要的是要强调重载函数必须具有一个共同的初始参数序列。除此以外，
我们上面的计划不起作用。如果不是这种情况，我们必须手动包装我们的函数。

实际上，我们可以通过BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS及其姐妹BOOST_PYTHON_FUNCTION_OVERLOADS来混合和匹配重载函数的手动换行和自动换行。
按照我们在重载部分中提供的示例，由于前4个重载函数有一个共同的初始参数序列，我们可以使用BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS自动换行前三个defs并手动换行最后一个。以下是我们将如何做到这一点：

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(xf_overloads, f, 1, 4)

为X :: f重载创建一个成员函数指针，如上所示：

bool    (X::*fx1)(int, double, char)    = &X::f;
int     (X::*fx2)(int, int, int)        = &X::f;

然后...

.def("f", fx1, xf_overloads());
.def("f", fx2)