member-function-pointers

Let's say I have a pointer type that can hold the address of a base class method. Can I assign the address of a subclass method to it and expect it to work correctly? In my case I'm using it with a base class pointer and the dynamic type of the object is the derived class. struct B { typedef void (B::*MethodPtr)(); }; struct D: public B { void foo() { cout<<"foo"<<endl; } }; int main(int argc, char* argv[]) { D d; B* pb = &d; //is the following ok, or undefined behavior? B::MethodPtr mp = static_cast<B::MethodPtr>(&D::foo); (pb->*mp)(); } The standard says this when talking about static_cast:

I have a callback mechanism, the classes involved are: class App { void onEvent(const MyEvent& event); void onEvent(const MyOtherEvent& event); Connector connect; } class Connector { template <class T> void Subscribe(boost::function <void (const T&)> callback); } App::App() { connect.Subscribe<MyEvent>(&App::OnEvent<MyEvent>); } First off this code doesn't compile, it's an illustration. The use of templates complicates my example, but I left them in because its affecting my problem. It seems certain to me that my subscribe needs to be templated because the Connector class doesn't know how many

If you have a struct like this one struct A { void func(); }; and a reference like this one A& a; you can get a pointer to its func method like this: someMethod(&A::func); Now what if that method is virtual and you don't know what it is at run-time? Why can't you get a pointer like this? someMethod(&a.func); Is it possible to get a pointer to that method? Pointers to members take into account the virtuality of the functions they point at. For example: #include <iostream> struct Base { virtual void f() { std::cout << "Base::f()" << std::endl; } }; struct Derived:Base { virtual void f() { std:

I'm new to c++ . I want to know about object pointer and pointer to member function . I wrote a code which is following: code : #include <iostream> using namespace std; class golu { int i; public: void man() { cout<<"\ntry to learn \n"; } }; int main() { golu m, *n; void golu:: *t =&golu::man(); //making pointer to member function n=&m;//confused is it object pointer n->*t(); } but when i compile it it shows me two error which is following: pcc.cpp: In function ‘int main()’: pcc.cpp:15: error: cannot declare pointer to ‘void’ member pcc.cpp:15: error: cannot call member function ‘void golu:

I'm trying to make some callbacks from member functions and everything was ok until I tried to use a template class derived from 2 classes as callback object when I got the following error: error C2440: 'reinterpret_cast' : Pointers to members have different representations; cannot cast between them This thing signaled me that member function pointers have different representations(doh!) What are these representations? What is the difference between them? Danny Kalev explains this quite nicely : The Underlying Representation of Pointers to Members Although pointers to members behave like

I'm trying to figure out a way of how to be able to assign a function pointer to functions with different number of arguments. I have a while loop which takes a number of different functions as a conditional statement, so instead of writing multiple while loops with exactly the same code inside I'd like to have one with a function pointer. All the functions are of format bool f(...) . I think some code will best illustrate what I mean: int a, b, c, d; MyClass* my_class; typedef bool (MyClass::*my_fun_t)(); my_fun_t my_fun; if (condition1) my_fun = &MyClass::function_one(); else if (condition2)

Isn't a pointer just an address? Or I'm missing something? I tested with several types of pointers: pointers to any variables is the same (8B on my platform) pointers to functions are the same size, as pointers to variables (8B again) pointers to functions with different parameters - still the same (8B) BUT pointers to member functions are bigger - 16B on my platform. Three things: Why are pointers to member functions bigger? What more information do they need? As far as I know, the standard says nothing about the size of a pointer, except that void* must be able to "contain" any pointer type.