Вызвать метод базового класса при разрушении дочернего объекта

#include <thread>
#include <atomic>
#include <iostream>
#include <mutex>
#include <sstream>
#include <boost/asio/io_service.hpp>
#include <boost/signals2.hpp>

std::ostream&
print_one(std::ostream& os)
{
    return os;
}

template <class A0, class... Args>
std::ostream&
print_one(std::ostream& os, const A0& a0, const Args&... args)
{
    os << a0;
    return print_one(os, args...);
}

template <class... Args>
std::ostream&
print(std::ostream& os, const Args&... args)
{
    std::ostream& result = print_one(os, args...);
    os.flush();
    return result;
}

template <class... Args>
std::ostream&
print(const Args&... args)
{
    static std::mutex m;
    std::lock_guard<std::mutex> lg(m);
    return print(std::cout, args...);
}

class BaseActor {
public:
    virtual ~BaseActor()
    {
        assert(!thread_.joinable() && "Derivative classes MUST call stop() from their destructors");
    }

    void start()
    {
        stop();
        io_service_.reset();
        work_.reset(new boost::asio::io_service::work(io_service_));
        std::thread(std::bind(&BaseActor::threadFunc_, this)).swap(thread_);
    }

    void stop()
    {
        work_.reset();
        io_service_.stop();
        if (thread_.joinable())
            thread_.join();
    }

protected:
    BaseActor()
        : thread_()
    {
    }
    virtual void threadFunc_() { io_service_.run(); }

protected:
    template <class T, class... Args>
    std::function<void(Args...)> makeSlotProxy_(void (T::*f)(Args...))
    {
        return io_service_.wrap([this, f](Args&&... args) { (static_cast<T*>(this)->*f)(std::forward<Args>(args)...); });
    }

    template <typename F>
    class FunctorTraits_;
    template <class R, class T, class... Args>
    class FunctorTraits_<R (T::*)(Args...)> {
    public:
        typedef std::function<R(Args...)> FunctorType;
    };

    template <typename F, F>
    class SlotProxyFactory_;
    template <typename T, typename... Args, void (T::*F)(Args...)>
    class SlotProxyFactory_<void (T::*)(Args...), F> {
    public:
        SlotProxyFactory_(T* c)
            : t_(c)
        {
        }

        std::function<void(Args...)> operator()()
        {
            return t_->io_service_.wrap([&](Args&&... args) { (t_->*F)(std::forward<Args>(args)...); });
        }

    private:
        T* t_ = nullptr;
    };

protected:
    std::thread thread_;
    std::unique_ptr<boost::asio::io_service::work> work_;
    boost::asio::io_service io_service_;
};

class ActorA : public BaseActor {
public:
    ~ActorA() { stop(); }

public:
    boost::signals2::signal<void(const std::string&)> helloSig;
    std::atomic_int aNumber{ 0 };

protected:
    virtual void threadFunc_() override
    {
        print("ActorA has started", "\n");
        BaseActor::threadFunc_();
        print("ActorA has finished", "\n");
    }

private:
    void doJobA_(const int& num)
    {
        print("ActorA::doJobA_() from thread ", thread_.get_id(), "\n");
        print("num = ", num, "\n");
        std::ostringstream oss;
        oss << "Hello, World " << num << "!";
        helloSig(oss.str());
        aNumber.store(num);
    }

public:
    FunctorTraits_<decltype(&ActorA::doJobA_)>::FunctorType jobASlot()
    {
        return makeSlotProxy_(&ActorA::doJobA_);
    }
};

class ActorB : public BaseActor {
public:
    ~ActorB() { stop(); }

public:
    boost::signals2::signal<void(const int&)> intSig;

protected:
    virtual void threadFunc_() override
    {
        print("ActorB has started", "\n");
        BaseActor::threadFunc_();
        print("ActorB has finished", "\n");
    }

private:
    void doJobB_(const std::string& str)
    {
        print("ActorB::doJobB_() from thread ", thread_.get_id(), "\n");
        print("str = ", str, "\n");
        intSig(++count_);
        aString_ = str;
    }

public:
    FunctorTraits_<decltype(&ActorB::doJobB_)>::FunctorType getJobBSlot()
    {
        return makeSlotProxy_(&ActorB::doJobB_);
    }

    SlotProxyFactory_<decltype(&ActorB::doJobB_), &ActorB::doJobB_> jobBSlot{this};

private:
    int count_ = 0;
    std::string aString_;
};

int main()
{
    print("Main thread id is ", std::this_thread::get_id(), "\n");

    ActorA actorA;
    ActorB actorB;
    actorA.helloSig.connect(actorB.jobBSlot());
    actorB.intSig.connect(actorA.jobASlot());
    actorA.start();
    actorB.start();
    actorB.intSig(0);
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}