function-pointers

DISCLAIMER I DO NOT USE BOOST OR OTHER LIBRARIES Finally I've learned how PointerToMemberFunction works. This is my example code . #include <iostream> using namespace std; class Foo { public: void foo ( ) { cout << "I'm a foo method\n"; }; }; class Bar { public: void bar ( Foo* fooPtr , void(Foo::*fooFnPtr)() ) { (fooPtr->*fooFnPtr)(); }; }; int main() { Foo* foo = new Foo(); Bar* bar = new Bar(); bar->bar ( foo , &Foo::foo ); return 0; } Now, what the problem is. Bar::bar must be modified somehow, because in real project it won't know, what class fooFnPtr is a pointer to . In other words Bar:

I'm trying to use ctypes to call a c function that was returned as a pointer from another function. It seems from the documentation that I can do this by declaring the function with CFUNCTYPE , and then creating an instance using the pointer. This, however seems to give me a segfault. Here is some sample code. sample.c: #include <stdio.h> unsigned long long simple(void *ptr) { printf("pointer = %p\n", ptr); return (unsigned long long)ptr; } void *foo() { return (void *)simple; } unsigned long long (*bar)(void *ptr) = simple; int main() { bar(foo()); simple(foo()); } and simple.py: from ctypes

I have a C header with: typedef struct { <normal members> void (*cb_func)(glp_tree *T, void *info); void *cb_info; <normal members> } glp_iocp; Currently, in my pxd file: ctypedef struct IntOptCP "glp_iocp": <normal members> int out_dly # mip.out_dly (milliseconds) #void (*cb_func)(Tree* tree, void* info) # mip.cb_func #void* cb_info # mip.cb_info <normal members> In a pyx file, at some point, I do (essentially): cdef class MyClass: IntOptCP _iocp <__cintit__ and the like> def some_method(self): <manipulation of self._iocp> controls = dict() controls = self._iocp return controls This works

The example code is: #include <iostream> using std::cout; using std::endl; void bar(double *) { cout << "call bar()" << endl; } using Bar = void(*)(double *); template <Bar pfunction> void foo() { // when call "foo<bar>()", there is a warning: // the address of ‘void bar(double*)’ will never be NULL [-Waddress] if (nullptr != pfunction) { pfunction(nullptr); } cout << "shit" << endl; } int main() { foo<nullptr>(); // OK foo<bar>(); // warning return 0; } from gcc manual: -Waddress Warn about suspicious uses of memory addresses. These include using the address of a function in a conditional

Assuming I have this class: class Shape { public: int value; Shape(int v) : value(v) {}; void draw() { cout << "Drawn the element with id: " << value << endl; } }; and the following code (which works) Shape *myShapeObject = new Shape(22); void (Shape::*drawpntr)(); drawpntr = &Shape::draw; (myShapeObject ->*drawpntr)(); I have a drawpntr function pointer to a void-returning 0-arguments function member of the class Shape. First thing I'd like to ask: drawpntr = &Shape::draw; the function is a member function and there's no object here.. what address does drawpntr receive? The class shouldn't

This is a follow up on How do I get the argument types of a function pointer in a variadic template class? I have this struct to access the arguments of a variadic template: template<typename T> struct function_traits; template<typename R, typename ...Args> struct function_traits<std::function<R(Args...)>> { static const size_t nargs = sizeof...(Args); typedef R result_type; template <size_t i> struct arg { typedef typename std::tuple_element<i, std::tuple<Args...>>::type type; }; }; And I access the type of an argument of Args with typedef function<void(Args...)> fun; std::cout << std::is