c++ - 具有非双射参数类型映射的 C 函数到 C++ 实例成员蹦床

Question

编辑:我想我已经破解了，here

(这里的非双射意味着我们可能有类型为 const char 或 char* 的参数都映射到 const std::string&。)*

注意:几天来我一直在研究这个问题并提出类似的问题。不过，我将从头开始提供一个摘要，因为它可能会使这个问题成为一个不错的资源。

我有一个 C 函数指针:

R_c (*CFunc)( void* self, A1, A2, ..., Ak )
CFunc slot = nullptr;

以及相关的 C++ 方法:

class Base {
    R_cxx f_cxx( X1, X2, ..., Xk );
}

我需要创建一个转发机制。

C 库将调用 say x = slot(&someobject, 1, "two")，我的任务是创建一个 slot 函数，它将 trampoline到:

slot( void* self, A1 a1, A2 a2 ) { 
    R_cxx ret = ((Base*)self)->f_cxx( toCxx<A1>(a1), toCXX<A2>(a2) );
    return toC<R_cxx>(ret);
}

问题是我有将近 100 个不同的插槽，可能跨越 20 个不同的签名。所以我需要将其自动化。

我将从一个包含静态函数的模板开始:

template< typename F_c, typename F_Cxx >
struct Generator {
    static Bla call( etc ) {...}
};

#define BIND_SLOT( F_c, F_Cxx ) &Generator<F_c,F_Cxx>::call
:

BIND_SLOT( table->slot35, Base::handler_35 );

当然，那是半伪代码。实际上语法要复杂得多，因为您需要将 decltype(foofunc), foofunc 传递到模板中——仅仅 foofunc 是不够的(尽管有一些机会这将在 C++17 中修复)。中间模板层对于将函数签名拆分为 returntype、C++base 和 args 也是必需的。并且需要重载 toCXX(T t) 函数以将所有必要的 A_k 映射到 X_k。

多亏了this answer，我以为我昨天已经破解了这个.

解决方案是根据 f_cxx 的签名构造 C 函数签名。然而，我后来意识到，由于一个烦人的原因，这种方法行不通:两种不同的 C 类型映射到相同的 C++ 类型。

即插槽函数可能具有涉及 const char* 和 char* 的签名。但是这两个都映射到'const std::string&'。因此，该技术在遇到“const std::string&”时会失败——它不知道是转换回 char* 还是 const char*。

因此我尝试重写它，这次使用槽函数的签名，而不是 cxx 成员函数。

但是，这是极其复杂的代码，我正在努力。

Answer 1

1. 插槽的地址不是有效的模板参数。我没有花时间确定原因，但在下面的代码中我将其从参数列表中删除了。它没有在示例代码中使用。

2. 您的第一个 decltype 中有一个额外的 Table.，这使得表达式无效。删除它可以看到所有参数。在删除之前表达式变成了 Table.table.tp_getattr，这是无效的。

3. 您的 Return 类使用了 C 函数的返回类型，但您将其专门化为 C++ 函数的返回类型。

4. 您的一些助手正在做一些事情，例如返回对临时对象的引用或在需要引用时返回指针。我也对它们进行了一些清理，但请注意它会泄漏内存。

更新的代码(在 g++ 4.7.3 上编译):

#include <iostream>
#include <typeinfo>
#include <utility>

struct PyObject
{
    PyObject(int i_) : i{i_} {}
    int i;
};

struct Object
{
    // avoid implicit conversion
    explicit Object(PyObject* p_) : p{p_} { 
        std::cout << "Converting PyObject: " << p->i << std::endl; 
    }

    PyObject* ptr() const {
        return p;
    }  
private:
    PyObject* p;
};

struct Table {
    typedef PyObject*   (*getattrfunc)  (PyObject *, char *     );
    typedef PyObject*   (*getattrofunc) (PyObject *, PyObject * );
    typedef int         (*setattrfunc)  (PyObject *, char *     , PyObject *);
    typedef int         (*setattrofunc) (PyObject *, PyObject * , PyObject *);

    getattrfunc tp_getattr;
    setattrfunc tp_setattr;
    getattrofunc tp_getattro;
    setattrofunc tp_setattro;
} table{};

class Base {
public:
    Object  getattr( const std::string& s )                     { std::cout << "Base::getattr" << std::endl; return Object{ new PyObject(42) }; }
    int     setattr( const std::string& s, const Object& value ){ std::cout << "Base::setattr" << std::endl; return 666; }
};

class Final : public Base {
public:
    Object getattr( const std::string& s ){ std::cout << "Final::getattr" << std::endl; return Object{ new PyObject(43) }; }
} final{};

// helpers
template<typename T, typename U>       U&& mapperC2CXX( T&& t )         { return std::forward<U&&>(t); }
template<typename T>    const std::string& mapperC2CXX(       char* t ) { return *new std::string(t); }
template<typename T>    const std::string& mapperC2CXX( const char* t ) { return *new std::string(t); }
template<typename T>    const std::string& mapperC2CXX( PyObject*   p ) { return *new Object{p}; }

template<typename T> 
struct Return {
    static T&& cvalue(T&& t) { return std::forward<T>(t); }
    static T cerr()        { return T(-1); }
};
template<>
struct Return<Object> {
    static PyObject* cvalue(const Object& ob)   { return ob.ptr(); }
    static PyObject* cerr()                     { return (PyObject*)nullptr; }
};

// function generator
template<typename Fc, typename Target, Target target>
struct Generate;

template <  typename R      , typename ...Arg       ,
            typename RTarg  , typename ...TargArg   , RTarg(Base::*target)(TargArg...) >
struct Generate< R(*)(PyObject*, Arg...)    ,
                 RTarg(Base::*)(TargArg...) , target >
{
    static Base* cxxbase_for(PyObject* pyob) {
        return (Base*)&final; // cheat for now!
    }

    static R call( PyObject* self, Arg... carg) 
    {
        try
        {
            RTarg r_cxx = (cxxbase_for(self)->*target) (mapperC2CXX<Arg>(carg)...);
            return Return<RTarg>::cvalue(r_cxx);
        }
        catch (...)
        {
            std::cout << "CAUGHT" << std::endl;
            return Return<R>::cerr();
        }
    }   
};

#define BIND(c_slot, cxx_target) c_slot = & Generate< decltype(c_slot),   decltype(&cxx_target), &cxx_target >::call;

int main()
{
    BIND( table.tp_getattr, Base::getattr );

    // test -- imagine C library fires this
    PyObject* self = (PyObject*)&final;
    PyObject* pyob = table.tp_getattr( self, (char*)"someattribute" );

    std::cout << pyob->i << std::endl;
}