class classe {
public:
    std::thread *THREAD = NULL;
    void Func() {}
    classe() {
        THREAD = new std::thread(Func);
    }
    ~classe() {
        delete THREAD;
    }
};

delete[] THREAD;

#include <thread>
#include <memory>
#include <atomic>

class classe
{
public:
classe() : m_thread(nullptr){}

void start()
{
  m_running.store(true);
  m_thread.reset(new std::thread(&classe::worker, this));
}

// thread que invoca stop() será bloqueada até que worker tenha completado
void stop()
{
  m_running.store(false);
  m_thread->join(); //não esqueça dessa parte =) (se seu worker estiver em foreground)
}
private:

void worker()
{
  while(m_running.load())
  {
    // realize algum processo
  }
}

std::unique_ptr<std::thread> m_thread;
std::atomic<bool> m_running;
};

using SPtr = std::shared_ptr<int>;

{

  SPtr original(new int(10));

  original.use_count(); // retorna 1

  {

    SPtr segundo = original;

    original.use_count(); // retorna 2

    // "original" e "segundo" compartilham o mesmo ponteiro para um inteiro;

  } // fim do escopo, "segundo" será destruído na stack

  original.use_count(); // retorna 1

} // fim do escopo, original será destruido e ficando com use_count() igual a 0 e com isso o pointero será deletado automaticamente;