function-pointers

I think it would be easier to use function pointers if I created a typedef for a function pointer, but I seem to be getting myself tripped up on some syntax or usage or something about typedef for function pointers, and I could use some help. I've got int foo(int i){ return i + 1;} typedef <???> g; int hvar; hvar = g(3) That's basically what I'm trying to accomplish I'm a rather new C programmer and this is throwing me too much. What replaces <???> ? Your question isn't clear, but I think you might want something like this: int foo(int i){ return i + 1;} typedef int (*g)(int); // Declare

Consider this code: #include <iostream> using namespace std; class hello{ public: void f(){ cout<<"f"<<endl; } virtual void ff(){ cout<<"ff"<<endl; } }; #define call_mem_fn(object, ptr) ((object).*(ptr)) template<R (C::*ptr_to_mem)(Args...)> void proxycall(C& obj){ cout<<"hello"<<endl; call_mem_fn(obj, ptr_to_mem)(); } int main(){ hello obj; proxycall<&hello::f>(obj); } Of course this won't compile at line 16, because the compiler doesn't know what R , C and Args , are. But there's another problem: if one tries to define those template parameters right before ptr_to_mem , he runs into this bad

I'm trying to figure out how to execute machine code stored in memory. I have the following code: #include <stdio.h> #include <stdlib.h> int main(int argc, char* argv[]) { FILE* f = fopen(argv[1], "rb"); fseek(f, 0, SEEK_END); unsigned int len = ftell(f); fseek(f, 0, SEEK_SET); char* bin = (char*)malloc(len); fread(bin, 1, len, f); fclose(f); return ((int (*)(int, char *)) bin)(argc-1, argv[1]); } The code above compiles fine in GCC, but when I try and execute the program from the command line like this: ./my_prog /bin/echo hello The program segfaults. I've figured out the problem is on the

When implementing polymorphic behavior in C++ one can either use a pure virtual method or one can use function pointers (or functors). For example an asynchronous callback can be implemented by: Approach 1 class Callback { public: Callback(); ~Callback(); void go(); protected: virtual void doGo() = 0; }; //Constructor and Destructor void Callback::go() { doGo(); } So to use the callback here, you would need to override the doGo() method to call whatever function you want Approach 2 typedef void (CallbackFunction*)(void*) class Callback { public: Callback(CallbackFunction* func, void* param);

In Bjarne Stroustrup 's home page ( C++11 FAQ ): struct X { int foo(int); }; std::function<int(X*, int)> f; f = &X::foo; //pointer to member X x; int v = f(&x, 5); //call X::foo() for x with 5 How does it work? How does std::function call a foo member function ? The template parameter is int(X*, int) , is &X::foo converted from the member function pointer to a non-member function pointer ?! (int(*)(X*, int))&X::foo //casting (int(X::*)(int) to (int(*)(X*, int)) To clarify: I know that we don't need to cast any pointer to use std::function , but I don't know how the internals of std::function

I am presently in a case where I need to call a lot of function pointers that has been extracted at runtime. The problem is that the arguments are unknown at compilation time. But, at runtime I receive datas that allows me to know the arguments of the function and I can even store the arguments in a char* array. The problem is that I don't have a function pointer model to cast it into. In high level language, I know there is function like "InvokeMethode(String name,Byte[] args)" that interpret the bytes array like arguments. Since reflection does not exist in C, I have no hope to see this with

I am trying to learn some c# coding and wondering if the c++ concept of function pointers is included in c#. I see there are such things as delegates. Are they the same concept? or do they differ on a more fundamental level? Delegates are essentially function pointers, but with extra multicast capabilities built in. So you can assign several functions to the same delegate, and they will all be called in sequence when the delegate is called. Delegates also have built-in asynchronous interfaces, and have co/contra variance when assigning new functions to a delegate (and, in .NET 4, when passing