C++のクラス内関数をタイマハンドラに渡したいができない

Question

Linuxのタイマハンドラを利用してインターバルタイマを使おうと思ったのですがクラス内関数をハンドラに登録が出来ない事が分かり困っています。
下記に状況を再現したコードとコンパイルエラーの内容を添付します。

ライブラリの変更等も含めてこの状況を解決できる方法は何か無いでしょうか。

#include <sys/time.h>
#include <signal.h>
#include <string.h>
#include <iostream>
#include <time.h>


class timer_test{
private:
    struct sigaction action;
    struct itimerval timer;
    struct timespec timer_count, last_time_timer_count;
    int counter = 0;
    int nsec;

public:
    timer_test(){
        memset(&action, 0, sizeof(action));
    }


    int timer_start(void){
        scheduler_setup(100000);
        while(counter < 50){
            _nanosleep(0, 50);   
            timer.it_interval.tv_usec = 0;
            timer.it_value.tv_usec = 0;
            setitimer(ITIMER_REAL, &timer, NULL);
        }
        return 0;
    }

private:
    int scheduler_setup(int interval_us){
        struct sigaction action;
        // set signal handler
        action.sa_handler = SignalHandler;
        action.sa_flags = SA_RESTART;
        sigemptyset(&action.sa_mask);
        if(sigaction(SIGALRM, &action, NULL) < 0){
            std::cout << "sigaction error" << std::endl;
            exit(1);
        }
        // set intarval timer
        timer.it_value.tv_sec = 0;
        timer.it_value.tv_usec = interval_us;
        timer.it_interval.tv_sec = 0;
        timer.it_interval.tv_usec = interval_us;
        if(setitimer(ITIMER_REAL, &timer, NULL) < 0){
            std::cout << "setitimer error" << std::endl;
            return 1;
        }
        clock_gettime(CLOCK_REALTIME, &last_time_timer_count);
        return 0;
    }


    void SignalHandler(int signum){
        static unsigned long cnt = 1;
        static unsigned long sum = 0;
        static unsigned int ave = 0;

        clock_gettime(CLOCK_REALTIME, &timer_count);
        nsec = timer_count.tv_nsec - last_time_timer_count.tv_nsec;
        if(nsec > 0){
            sum += nsec;
            ave = sum / cnt;
            cnt++;
        }
        std::cout << "SignalHandler:" << nsec / 1000 << "usec\n" << std::endl;
        std::cout << "ave:" << ave / 1000 << "usec\n" << std::endl;
        last_time_timer_count = timer_count;
        counter++;

        return;
    }


    int _nanosleep(int sec, int nsec){
        struct timespec req, rem;
        req.tv_sec = sec;
        req.tv_nsec = nsec;
        rem.tv_sec = 0;
        rem.tv_nsec = 0;
        while(nanosleep(&req, &rem)){
            if(errno == EINTR){
                req.tv_sec = rem.tv_sec;
                req.tv_nsec = rem.tv_nsec;
            }else{
                perror("nanosleep error");
                return -1;
            }
        }
        return 0;
    }
};


int main(void)
{
    timer_test *t = new timer_test();
    t -> timer_start();
    return 0;
}

$ g++ timer_test.cpp -std=c++11

timer_test.cpp: In member function ‘int timer_test::scheduler_setup(int)’:
timer_test.cpp:38:27: error: cannot convert ‘timer_test::SignalHandler’ from type ‘void (timer_test::)(int)’ to type ‘__sighandler_t {aka void (*)(int)}’
         action.sa_handler = SignalHandler;
                           ^

Answer 1

非メンバ関数とメンバ関数は型が異なります。 非メンバ関数を要求しているところにメンバ関数を渡すことは出来ません。

メンバ関数はオブジェクトとセットでなければ実行することが出来ない存在です。 この場合に SignalHandler を渡されたとして、どのオブジェクトを参照すればよいのか sigaction はわかりません。

SignalHandler を非メンバ関数になるように変形するか、 static で修飾する (事実上非メンバ関数に変形するのと手間は同じでしょう) か、あるいは std::mem_fn や std::bind など (あるいはラムダ式) を使ってオブジェクトとメンバ関数を結び付けてから渡すといったような対処が考えられます。

Comments

[Kitano]

回答ありがとうございます。
「非メンバ関数とメンバ関数は型が異なります。 非メンバ関数を要求しているところにメンバ関数を渡すことは出来ません。」というのはその通りで説明が足りず、すみません。

今回SignalHandlerはメンバ変数にアクセスしているので非メンバ関数にするのは難しく、出来れば避けたいです。

そこで教えて頂いた「std::mem_fn や、std::bind 、ラムダ式」を用いてオブジェクトとメンバ関数を結び付けてから渡す方法を試してみたのですが結局エラーが出てしまいました。上記のプログラムの60行目のみ書き換えています。何か書き方が良く無かったのでしょうか。ご教授頂けると幸いです。

std::mem_fnの場合
書き換えた60行目の内容
action.sa_handler = std::mem_fn(&timer_test::SignalHandler);
エラー文
timer_test.cpp: In member function ‘int timer_test::scheduler_setup(int)’:
timer_test.cpp:61:27: error: cannot convert ‘std::_Mem_fn<void (timer_test::*)(int)>’ to ‘__sighandler_t {aka void (*)(int)}’ in assignment
action.sa_handler = std::mem_fn(&timer_test::SignalHandler);

std::bindの場合
書き換えた60行目の内容
action.sa_handler = std::bind(&timer_test::SignalHandler, this, std::placeholders::_1);
エラー文
timer_test.cpp: In member function ‘int timer_test::scheduler_setup(int)’:
timer_test.cpp:62:27: error: cannot convert ‘std::_Bind_helper<false, void (timer_test::*)(int), timer_test*, const std::_Placeholder<1>&>::type {aka std::_Bind<std::_Mem_fn<void (timer_test::*)(int)>(timer_test*, std::_Placeholder<1>)>}’ to ‘__sighandler_t {aka void (*) (int)}’ in assignment
action.sa_handler = std::bind(&timer_test::SignalHandler, this, std::placeholders::_1);

ラムダ式の場合
書き換えた60行目の内容
action.sa_handler = [](int n){this::SignalHandler(n);};
エラー文
timer_test.cpp: In lambda function:
timer_test.cpp:63:39: error: ‘this’ was not captured for this lambda function
action.sa_handler = [](int n){this::SignalHandler(n);};

[SaitoAtsushi]

`std::mem_fn` はメンバ関数を関数オブジェクトにする関数ですが、オブジェクトと結びつける機能はないです。 `std::bind` は Callable なオブジェクト (関数ポインタや関数オブジェクト) に引数を適用する機能はありますが、メンバ関数は Callable ではないので使えません。 `std::mem_fn` と `std::bind` を組み合わせて使うということを意図していました。

ただし `std::bind` の出力は未規定の Callable オブジェクトであり、関数ではありませんのでそのままではハンドラに出来ません。 この方法を使う場合でも一旦は非メンバ関数 (または `static` なメンバ関数) を経由する必要はあります。 複雑な変形をするよりは非メンバ関数の中でこれらのことをすると少しは簡単になるかもしれないといった程度のことで、非メンバ関数を使わないという選択は不可能です。

ラムダ式内で `this` を使うには `this` をキャプチャしておく必要があります。 ラムダ式が生成する関数はキャプチャする変数がない場合に限って関数ポインタに型変換できるというルールがありますが、 `this` を使うとなるとラムダ式では関数ポインタを作れません。

つまりラムダ式を使う場合でも同様に非メンバ関数 (または `static` なメンバ関数) を作る必要があります。

[Kitano]

詳しい説明ありがとうございます。
結局のところタイマハンドラに渡す関数をクラス外に出すか、staticにするしかないという事でしょうか。

となると本来のプログラムの方では大きく実装を変える必要があるのでどの様に変更すると関数をstaticにできるか検討し直してみます。

ありがとうございました。

Answer 2

よくあるthunkをつくれば解決する話ではありますね。シグナルハンドラ自体がプロセスで固定個数なので、C++のクラス(インスタンス)と繋げるならグローバル変数経由でいいんじゃないかな。
・インスタンスをグローバル変数としておきコンストラクタなりtimer_startのタイミングでthisを代入しておきます。
(ここではclass timer_test *gtimer;とでも定義しましょうか。シングルトンにしたいとかはお好きなように。)
・gtimer->SignalHandler(signum)を呼ぶだけの、staticなハンドラ関数(thunk)を作る。
・sigactionにはthunkを登録する。

ただそうしてインスタンスとつなげたとしても、signal handlerには、async-signal-safeな関数しか呼べない、というキツい制限が有るんですよね、、、