c ++ 11 — батут C-func к экземпляру-члену C ++ с небиективным отображением типа аргумента
РЕДАКТИРОВАТЬ: Я думаю, что я взломал его, Вот
(Здесь не биективно означает, что у нас могут быть аргументы типа 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 собирается вызвать, скажем, x = slot(&someobject, 1, "two")и моя задача — создать slot функция, которая будет батут к:
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.
Я думал, что у меня это взломали вчера благодаря этот ответ.
Решение состояло в том, чтобы создать сигнатуру функции C из сигнатуры f_cxx. Однако с тех пор я понял, что этот подход не будет работать по одной раздражающей причине: два разных C-типа отображаются на один и тот же тип C ++.
то есть функция слота может иметь подпись, включающую const char* а также char*, Но оба они отображаются на ‘const std :: string&». Так что этот метод потерпит неудачу в тот момент, когда он встретит ‘const std :: string&’- он не знает, нужно ли конвертировать обратно в char* или же const char*,
Поэтому я пытаюсь переписать его, на этот раз используя сигнатуру функции slot вместо функции-члена cxx.
Тем не менее, это чрезвычайно сложный код, и я изо всех сил.
Решение
-
Адрес слота не является допустимым параметром шаблона. Я не потратил время, чтобы определить причину, но в приведенном ниже коде я удалил его из списка параметров. Он не использовался в примере кода.
-
Ты первый
decltypeимеет дополнительныйTable.в нем, что делает выражение недействительным. Удаление этого позволяет увидеть все аргументы. Выражение сталоTable.table.tp_getattrдо этого был удален, что было недействительным. -
Ваш
Returnкласс использовал возвращаемый тип функции C, но вы специализировали его на возвращаемом типе функции C ++. -
Некоторые из ваших помощников делают такие вещи, как возврат ссылки на временный объект или возврат указателя, когда ссылка ожидалась. Я тоже немного их почистил, но учтите, что это приводит к утечке памяти.
Обновленный код (компилируется на 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;
}
Другие решения