Boost Python avvolge sovraccarico di funzione membro statico con argomento predefinito

Question

Ho l'esempio di wrapper C++ allegato per python: La funzione membro (metodo) è statica con argomento predefinito. Quindi uso BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS per definire la funzione di sovraccarico. Non v'è alcun errore di compilazione, ma quando chiamo la funzione di membro static ho ottenuto l'errore come segue:

import boostPythonTest  
boostPythonTest.C.method("string") 

--------------------------------------------------------------------------- ArgumentError Traceback (most recent call last) 
<ipython-input-4-ab141804179c> in <module>() 
----> 1 boostPythonTest.C.method("string") 

ArgumentError: Python argument types in 
C.method(str) did not match C++ signature: 

method(class C {lvalue}, class std::basic_string<char,struct 
std::char_traits<char>,class std::allocator<char> >) 

method(class C {lvalue}, class std::basic_string<char,struct 
std::char_traits<char>,class std::allocator<char> >, int) 

method(class C {lvalue}, class std::basic_string<char,struct 
std::char_traits<char>,class std::allocator<char> >, int, bool) 

non capisco il motivo per cui la prima firma generato è di "classe C { lvalue}". Se è così, la funzione membro statica ha bisogno di un'istanza di C per essere chiamata, sembra contraddittoria per me.

D'altra parte, definisco un'altra funzione membro statica senza utilizzare la funzione di sovraccarico della funzione membro, funziona senza la firma "classe C {lvalue}". Per esempio:

boostPythonTest.C.noDefaultArgMethod("string", 0, True) 

Tipo: funzione sotto forma di stringa: docstring: noDefaultArgMethod ((str) arg1, (int) arg2, (bool) arg3) -> int:

C++ signature : 
    int noDefaultArgMethod(

classe std :: basic_string, classe std :: allocator>, int, bool)

qualcuno potrebbe aiutare a spiegare il problema con BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS, o dare così suggerisco come usarlo come vera funzione membro statico con sovraccarico?

#include <boost/python/module.hpp> 
#include <boost/python/def.hpp> 
#include <boost/python/args.hpp> 
#include <boost/python/tuple.hpp> 
#include <boost/python/class.hpp> 
#include <boost/python/overloads.hpp> 
#include <boost/python/return_internal_reference.hpp> 
#include <boost/python/register_ptr_to_python.hpp> 
#include <boost/python/object/class.hpp> 

using namespace boost::python; 

class C { 
public: 
    static int method(const std::string &arg1, int arg2 = 0, bool arg3 = true) { 
     return 1; 
    }; 

    static int noDefaultArgMethod(const std::string &arg1, int arg2 = 0, bool arg3 = true) { 
     return 10; 
    }; 

}; 

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(method1, C::method, 1, 3) 

BOOST_PYTHON_MODULE(boostPythonTest) 
{ 

    class_<C>("C") 
     .def("method", (int(C::*)(const std::string&, int, bool))0, method1()) 
     .staticmethod("method") 
     .def("noDefaultArgMethod", &C::noDefaultArgMethod) 
     .staticmethod("noDefaultArgMethod"); 

} 

Answer 1

credo che questa linea:

.def("method", (int(C::*)(const std::string&, int, bool))0, method1()) 

dovrebbe assomigliare a questo:

.def("method", &C::method, method1()) 

e si dovrebbe utilizzare BOOST_PYTHON_FUNCTION_OVERLOADS invece di BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS, poiché non c'è C oggetto coinvolto (puntatori a funzione statica sono solo puntatori di funzione, non sono puntatori ai membri).

C'è anche un esempio postato su this wiki con funzioni statiche sovraccarico, in cui la sezione pertinente sarebbe:

class X { 
    static int returnsum(int m, int x = 10) { return m + x; } 
}; 

BOOST_PYTHON_FUNCTION_OVERLOADS(X_returnsum_overloads, X::returnsum, 1, 2) 

BOOST_PYTHON_MODULE(foo) 
{ 
    class_<X>("X", ..) 
     .def("returnsum", &X::returnsum, 
      X_returnsum_overloads(args("x", "m"), "returnsum's docstring") 
      ) 
     .staticmethod("returnsum") 
     ; 
} 

che sembra esattamente quello che vuoi.