member-function-pointers

#include <iostream> class A { protected: void foo() {} }; class B : public A { public: void bar() { std::cout << (&A::foo) << std::endl; } }; int main() { B b; b.bar(); } Here I am trying to get address of protected member function of base class. I am getting this error. main.cpp: In member function ‘void B::bar()’: main.cpp:5: error: ‘void A::foo()’ is protected main.cpp:13: error: within this context make: *** [all] Error 1 Changing foo to public works. Also printing &B::foo works. Can you please explain why we can't get address of protected member function of base class? B is allowed to

I have this C++ class that one big complicated method compute that I would like to feed with a "compute kernel", a method of the same class. I figure I would do something along the lines of class test { int classVar_ = 42; int compute_add(int a, int b) { compute(int a, int b, this->add_()) } int compute_mult(int a, int b) { compute(int a, int b, this->mult_()) } int compute_(int a, int b, "pass in add or multiply as f()") { int c=0; // Some complex loops { c += f(a,b) // } return c; } int add_(int a, int b){a+b+classVar_;} int multiply_(int a, int b){a*b+classVar_;} ... } but I'm not sure how

In C++, is it possible to define a sort order for pointers to member functions? It seems that the operator< is undefined. Also, it's illegal to cast to void*. class A { public: void Test1(){} void Test2(){} }; int main() { void (A::* const one)() = &A::Test1; void (A::* const two)() = &A::Test2; bool equal = one == two; //Equality works fine. bool less = one < two; //Less than doesn't. return 0; } Thanks! Function pointers are not relationally comparable in C++. Equality comparisons are supported, except for situations when at least one of the pointers actually points to a virtual member

struct A { void f() {} }; void f() {} int main() { auto p1 = &f; // ok auto p2 = f; // ok auto p3 = &A::f; // ok // // error : call to non-static member function // without an object argument // auto p4 = A::f; // Why not ok? } Why must I use address-of operator to get a pointer to a member function? auto p1 = &f; // ok auto p2 = f; // ok The first is more or less the right thing. But because non-member functions have implicit conversions to pointers, the & isn't necessary. C++ makes that conversion, same applies to static member functions. To quote from cppreference : An lvalue of function

I want to stop the warning server.cpp:823: warning: converting from 'void* (ClientHandler:: )()' to 'void ( )(void )' in the call: pthread_create(th, NULL, (void* (*)(void*)) &ClientHandler::handle, (void *) clientHandler); where handle() is a member function of ClientHandler : void* ClientHandler::handle(); I have difficulties deciphering the function-type message from the compiler. The question is: Should I change the handle() interface? Can I get rid of casting overall? Should I change the cast? To what exactly? Something completely different? Mat You can't do that directly, pointers to

What are the existing rules for taking function pointers or member function pointers to Standard functions? For example, something like auto p = &std::string::size; Is this legal? Would it be more or less legal if I explicitly requested the correct type, so it would function even if there was an additional implementation-added overload of std::string::size ? Using the "correct" type doesn't make things better: Except for the virtual functions all functions in the standard C++ library can have additional arguments as long as these are defaulted. Since the functions can also be declared with

Is there some library that allows me to easily and conveniently create Object-Oriented callbacks in c++? the language Eiffel for example has the concept of "agents" which more or less work like this: class Foo{ public: Bar* bar; Foo(){ bar = new Bar(); bar->publisher.extend(agent say(?,"Hi from Foo!", ?)); bar->invokeCallback(); } say(string strA, string strB, int number){ print(strA + " " + strB + " " + number.out); } } class Bar{ public: ActionSequence<string, int> publisher; Bar(){} invokeCallback(){ publisher.call("Hi from Bar!", 3); } } output will be: Hi from Bar! 3 Hi from Foo! So - the