How to call atomic member function pointer

As super pointed out you need to use the object twice:

(t.*t._processPtr.load())();
 ^  ^             ^----- load() because it's an atomic variable
 |  |---- this loads the function pointer stored inside of t
 |------- actual Object to call the member function pointer on

So you end up with this:

int main(int argc, char** argv)
{
    test t;
    t._processPtr = &test::process;
    (t.*t._processPtr.load())();  
}

_processPtr is not availiable. make it public like so.

class test
{
public:
    typedef void(test::*ProcessPtr)();
    std::atomic<ProcessPtr> _processPtr;
    void process() {};
}

with atomic you use .store() and .load() to write and read. not sure how it works with pointers though.

I found out why. this relates to the template argument deduction.

If you see the template class 'atomic', have a class of primary T and class specialize with T *. then I compare the pointer to function and pointer to function member. code can be seen below:

#include <iostream>

template<typename T>
struct A
{ 
    static void Call(){std::cout << "Call T" << std::endl;}
};
template<typename T>
struct A<T*>
{ 
    static void Call(){std::cout << "Call T*" << std::endl;}
};

struct B {};

int main()
{
    A<void(B::*)()>::Call();
    A<void(*)()>::Call();
}

output:

Call T
Call T*

Suggest improvement, use a double pointer to function member:

update in class test, from std::atomic<ProcessPtr> _processPtr; to std::atomic<ProcessPtr*> _processPtr;

and update in main function:

int main()
{
    test t;
    test::ProcessPtr d = &test::process;
    t._processPtr = &d;
    (t.*(*(t._processPtr)))();  
}