Pointer to member object - Interrupt Thread

Question

This is a followup to a question I got answered yesterday.

I'm trying to make an interrupt thread for member functions but I have no clue what these errors are:

[vagrant@localhost projects]$ g++ -o test test.cpp -lpthread
test.cpp: In instantiation of ‘InterruptibleThread::InterruptibleThread(Function&&, Args&& ...)::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, Args&& ...)> [with auto:1 = void (MyClass::*)(int); Function = void (MyClass::*)(int); Args = {MyClass*, int}; std::atomic_bool = std::atomic<bool>]’:
/usr/local/include/c++/6.3.0/type_traits:2481:26:   required by substitution of ‘template<class _Fn, class ... _Args> static std::__result_of_success<decltype (declval<_Fn>()((declval<_Args>)()...)), std::__invoke_other> std::__result_of_other_impl::_S_test(int) [with _Fn = InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, MyClass*&&, int&&)>; _Args = {std::reference_wrapper<std::atomic<bool> >, std::reference_wrapper<std::atomic<bool> >, void (MyClass::*)(int), MyClass*, int}]’
/usr/local/include/c++/6.3.0/type_traits:2492:55:   required from ‘struct std::__result_of_impl<false, false, InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, MyClass*&&, int&&)>, std::reference_wrapper<std::atomic<bool> >, std::reference_wrapper<std::atomic<bool> >, void (MyClass::*)(int), MyClass*, int>’
/usr/local/include/c++/6.3.0/type_traits:2496:12:   required from ‘class std::result_of<InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, MyClass*&&, int&&)>(std::reference_wrapper<std::atomic<bool> >, std::reference_wrapper<std::atomic<bool> >, void (MyClass::*)(int), MyClass*, int)>’
/usr/local/include/c++/6.3.0/functional:1365:61:   required from ‘struct std::_Bind_simple<InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, MyClass*&&, int&&)>(std::reference_wrapper<std::atomic<bool> >, std::reference_wrapper<std::atomic<bool> >, void (MyClass::*)(int), MyClass*, int)>’
/usr/local/include/c++/6.3.0/thread:137:26:   required from ‘std::thread::thread(_Callable&&, _Args&& ...) [with _Callable = InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]::<lambda(std::atomic_bool&, std::atomic_bool&, auto:1&&, MyClass*&&, int&&)>; _Args = {std::reference_wrapper<std::atomic<bool> >, std::reference_wrapper<std::atomic<bool> >, void (MyClass::*)(int), MyClass*, int}]’
test.cpp:41:33:   required from ‘InterruptibleThread::InterruptibleThread(Function&&, Args&& ...) [with Function = void (MyClass::*)(int); Args = {MyClass*, int}]’
test.cpp:111:53:   required from here
test.cpp:36:9: error: must use ‘.*’ or ‘->*’ to call pointer-to-member function in ‘fxn (...)’, e.g. ‘(... ->* fxn) (...)’
      fxn( forward< Args >( args )... );

Current code:

using namespace std;

class InterruptThreadException {};

class InterruptibleThread {
private:
    static thread_local atomic_bool* stopRef;
    static thread_local atomic_bool* pauseRef;
    atomic_bool stopFlag{false};
    atomic_bool pauseFlag{false};
    thread thrd;

public:
    friend void checkForInterrupt( );
    template < typename Function, typename... Args >
    InterruptibleThread( Function&& _fxn, Args&&... _args )
        : thrd(
                []( atomic_bool& sr, atomic_bool& pr, auto&& fxn, Args&&... args ) {
                    stopRef = &sr;
                    pauseRef = &pr;
                    fxn( forward< Args >( args )... );
                },
                ref( stopFlag ),
                ref( pauseFlag ),
                forward< Function >( _fxn ),
                forward< Args >( _args )... ) {
        thrd.detach( );
    }
    bool stopping( ) const {
        return stopFlag.load( );
    }

    void stop( ) {
        stopFlag.store( true );
    }

    void pause( ) {
        pauseFlag.store( true );
        cout << "setting pause flag: " << pauseFlag.load( ) << endl;
    }

    void start( ) {
        pauseFlag.store( false );
    }
};

void checkForInterrupt( ) {
    cout << "Pause flag: " << InterruptibleThread::pauseRef->load( ) << endl;
    cout << "Stop flag: " << InterruptibleThread::stopRef->load( ) << endl;
    while ( InterruptibleThread::pauseRef->load( ) ) {
        cout << "Paused\n";
        this_thread::sleep_for( chrono::seconds( 1 ) );
    }
    if ( !InterruptibleThread::stopRef->load( ) ) {
        return;
    }
    throw InterruptThreadException( );
}

thread_local atomic_bool* InterruptibleThread::stopRef = nullptr;
thread_local atomic_bool* InterruptibleThread::pauseRef = nullptr;

void doWork( ) {
    int i = 0;
    try {
        while ( true ) {
            cout << "Checking for interrupt: " << i++ << endl;
            checkForInterrupt( );
            this_thread::sleep_for( chrono::seconds( 1 ) );
        }
    } catch ( InterruptThreadException ) {
        cout << "Interrupted\n\n";
    }
}

class MyClass {
private:
    int myInt;
    void setInt( int i ) {
        myInt = i;
    }

public:
    MyClass( ) : myInt( 1 ) {
    }
    void myWork( int i );
    void doWork( );
};

void MyClass::myWork( int i ) {
    setInt( i );
    cout << "myInt value: " << myInt << endl;
}

void MyClass::doWork( ) {
    InterruptibleThread t( &MyClass::myWork, this, 666 );
}

int main( ) {
    MyClass mc;
    mc.doWork( );

    cout << "Press enter to exit" << endl;
    getchar( );
    return 0;
}

I tried the compiler suggestion and got an error afterwards related to fold expressions (which afaik are C++17 and I'm not to be using anything beyond 14). Any idea how to get this to work?

I have a working version of this without using lambdas but I'm really curious how to get this to work with the original code.

Answer 1

Pointers to member functions are called using a different syntax than pointers to non-member functions or other functors. Since Function in your case is a void (MyClass::*)(int), you need to call it using the syntax (object.*fxn)(arg) or (objectPtr->*fxn)(arg).

If you've got access to C++17 features, you can use std::invoke to uniformly call different types of callables:

InterruptibleThread( Function&& _fxn, Args&&... _args )
    : thrd(
            []( atomic_bool& sr, atomic_bool& pr, auto&& fxn, auto&&... args ) {
                stopRef = &sr;
                pauseRef = ≺
                std::invoke(std::move(fxn), std::move(args)...);
            },
            //...

Note: I changed Args&&... args to auto&&... args since Args&&... could cause problems.

If you don't have access to C++17, you can implement invoke yourself fairly easily:

template <typename Callable,
          typename... Args,
          typename = std::enable_if_t<!std::is_member_function_pointer<Callable>::value>>
decltype(auto) invoke(Callable&& c, Args&&... args) {
    return std::forward<Callable>(c)(std::forward<Args>(args)...);
}

template <typename T,
          typename T2,
          typename Ret,
          typename... FuncArgs,
          typename... Args,
          typename = std::enable_if_t<!std::is_pointer<T2>::value>>
decltype(auto) invoke(Ret (T::*c)(FuncArgs...), T2&& t, Args&&... args) {
    return (std::forward<T>(t).*c)(std::forward<Args>(args)...);
}

template <typename T,
          typename T2,
          typename Ret,
          typename... FuncArgs,
          typename... Args>
decltype(auto) invoke(Ret (T::*c)(FuncArgs...), T2* t, Args&&... args) {
    return (t->*c)(std::forward<Args>(args)...);
}

This doesn't do everything that std::invoke does, but it does everything you need it for.