这是从信号处理程序返回值的可靠方法吗

我想收集已终止子流程的pid，但我在与信号处理程序通信时遇到了问题。。。我没有c（++）11。这个有效吗？还请考虑到我的程序将是多线程的（但队列将仅从一个线程使用）。

#include <iostream>
#include <csignal>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <sys/wait.h>
template<typename _ValueType, int _Capacity>
class signal_result_queue
{
public:
    static const int capacity = _Capacity;
    typedef _ValueType value_type;
private:
    //+1 so we can distinguish empty from full
    volatile value_type _data[capacity+1];
    volatile sig_atomic_t _base;
    volatile sig_atomic_t _next;
    volatile sig_atomic_t _overflows;
public:
    signal_result_queue()
    : _base(0)
    , _next(0)
    , _overflows(0)
    {}
    void push_sh(value_type value)
    {
        int base = _base; // we are not interrupted anyway
        int next = _next; // same here
        int before_base = wrap(base-1);
        if(next == before_base)
        {
            ++_overflows;
        }
        else
        {
            _data[next] = value;
            _next = wrap(next+1);
        }
    }
    int overflows_t1()
    {
        int overflows = _overflows;
        _overflows -= overflows;
        return overflows;
    }
    bool pop_t1(value_type& result)
    {
        // this is only changed by us.
        int base = _base;
        // It might increase but no problem
        int next = _next;
        if(base == next)
        {
            return false;
        }
        else
        {
            result = _data[base];
            _base = wrap(base+1);
            return true;
        }
    }
private:
    static int wrap( int i )
    {
        while(i>=capacity+1)
        {
            i-=(capacity+1);
        }
        while(i<0)
        {
            i+=(capacity+1);
        }
        return i;
    }
};
signal_result_queue<pid_t, 20> q;
void sigchld_handler(int)
{
    pid_t pid;
    while((pid = waitpid(static_cast<pid_t>(-1), 0, WNOHANG)) > 0){
        q.push_sh(pid);
    }
}
int main()
{
    struct sigaction sa;
    sa.sa_handler = &sigchld_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
    if (sigaction(SIGCHLD, &sa, 0) == -1) {
      perror(0);
      std::exit(1);
    }
    for(int i=0;i<10;i++)
    {
        pid_t pid = fork();
        if(pid == 0) // child
        {
            sleep(i);
            return 0;
        }
        else if(pid == -1) // error
        {
            std::cout << "fork error" << std::endl;
        }
        else // parent
        {
            std::cout << "fork pid: " << pid <<  std::endl;
        }
    }
    int terminated = 0;
    do
    {
        sleep(1);
        int overflows = q.overflows_t1();
        if(overflows > 0)
        {
            std::cout << "Overflow in queue:" << overflows << std::endl;
        }
        pid_t val;
        while(q.pop_t1(val))
        {
            terminated++;
            std::cout << "Terminated: " << val <<  std::endl;
        }
    } while(terminated < 10);
    return 0;
}