If neither join or detach is called with a std::thread object, then when the main thread terminates, it will result in an exception error.

One approach around this issue to to use a class such as this, which checks if the thread is joinable, and if so will detach it from the main thread.

In this way, no exception error is shown.

#include <iostream>
#include <thread>
 
class ThreadRAII
{
  std::thread & m_thread;
 
public:
  ThreadRAII(std::thread  & threadObj) : m_thread(threadObj)
  {
  }
  ~ThreadRAII()
  {
    // Check if thread is joinable then detach the thread.
    if(m_thread.joinable())
    {
      m_thread.detach();
    }
  }
};
 
 
void thread_function()
{
  for(int i = 0; i < 10000; i++);
    std::cout<<"thread_function Executing"<<std::endl;
}
 
 
int main()
{
  std::thread threadObj(thread_function);
 
  // If we comment this Line, then program will crash.
  ThreadRAII wrapperObj(threadObj);
 
return 0;
}

#include <iostream>
#include <thread>
#include <vector>
#include<mutex>
 
 
// Wallet provides a service to add money in a Wallet.
//
// The same Wallet object is used between different threads, so a Lock is needed in the addMoney() method of the Wallet.
//
// Acquire lock before increment the money of Wallet and release lock before leaving that function. 
//
// This member function, first acquires a lock then increments the internal money of wallet object by a specified count and then releases the lock.
class Wallet
{
  int mMoney;
  std::mutex mutex;
 
public:
  Wallet() :mMoney(0){}
  int getMoney()   {     return mMoney; }
  void addMoney(int money)
  {
    mutex.lock();
    for(int i = 0; i < money; ++i)
    {
      mMoney++;
    } 
    mutex.unlock();
  } 
};
 
 
// Five threads will share the same Wallet class object and each thread will add 1000 into the Wallet using the addMoney() member function in parallel.
//
// So, if initially the money in the wallet is 0, then then after completion of all the threads, the money in the Wallet should be 5000.
//
// Adding a mutex lock guarantees that Money in the Wallet will be 5000 at the end.
int testMultithreadedWallet()
{
  Wallet walletObject;
  std::vector<std::thread> threads;
  for(int i = 0; i < 5; ++i) {
    threads.push_back(std::thread(&Wallet::addMoney, &walletObject, 1000));
  } 
  for(int i = 0; i < threads.size() ; i++)
  {
    threads.at(i).join();
  } 
  return walletObject.getMoney();
} 
 
 
int main()
{
  int val = 0;
  for(int k = 0; k < 1000; k++)
  {
    if((val = testMultithreadedWallet()) != 5000)
    {
      std::cout << "Error at count = "<<k<<"  Money in Wallet = "<<val << std::endl;
      //break;
    } 
  } 
 
  return 0;
}