Terminate called without an active exception

class TestClass
{
public:
    TestClass()
    {
        auto func_ptr = &TestClass::Process;
        m_pthread = new std::thread(func_ptr, this);
    }
    ~TestClass() { delete m_pthread; }
private:
    void Process()
    {
          std::cerr << "run" <<  std::endl;
    }
    std::thread* m_pthread = nullptr;
};
 
int main(int argc, char *argv[])
{
    TestClass* ptc = new TestClass;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    delete ptc;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cerr << "finished" << std::endl;
    return 0;
}

class TestClass
{
public:
    TestClass()
    {
        auto func_ptr = &TestClass::Process;
        m_pthread = new std::thread(func_ptr, this);
        m_pthread->detach();
    }
    ~TestClass()
    {
        auto ret = fork();
        if (ret != 0) abort();
        delete m_pthread;
    }
    bool isRunning() const {return m_isRunning.load(); }
private:
    void Process()
    {
 
        std::cerr << "run code:";
 
        std::exception_ptr e_ptr;
        try
        {
            //throw "error";
            bool isRunn = isRunning();
            while(!isRunn)
            {
                isRunn = isRunning();
                //pthread_testcancel();
            }
 
            //m_active_flag_setter.set_value_at_thread_exit();
        }
        catch(...)
        {
            e_ptr = std::current_exception();
        }
    }
    std::thread* m_pthread = nullptr;
    std::atomic_bool m_isRunning = false;
};
 
int main(int argc, char *argv[])
{
    TestClass* ptc = new TestClass;
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    delete ptc;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cerr << "finished" << std::endl;
    return 0;
}

class TestClass
{
public:
    TestClass()
    {
        auto func_ptr = &TestClass::Process;
        m_pthread = new std::thread(func_ptr, this);
        m_pthread->detach();
    }
    ~TestClass()
    {
        delete m_pthread;
    }
 
    bool isRunning() const {return m_isRunning.load(); }
private:
    void Process()
    {
 
        std::cerr << "run code:";
        try
        {
            bool isRunn = isRunning();
            while(!isRunn)
            {
                isRunn = isRunning();
            }
 
        }
        catch(...)
        {
        }
    }
    std::thread* m_pthread = nullptr;
    std::atomic_bool m_isRunning = false;
};