struct A {
  int m_a;
  void f() {m_a++;}
  static DWORD WINAPI MyThreadFunc(LPVOID lpParam) {return 0;}
};

AfxBeginThread(MyThreadFunc, this)

DWORD WINAPI MyThreadFunc(LPVOID lpParam) {
  A *a = static_cast<A*>(lpParam);
  а-> вызываем что угодно
  return 0;
}

struct A {
  int m_a;
  void f() {m_a++;}
  static DWORD WINAPI MyThreadFunc(LPVOID lpParam);
  DWORD RealThreadFunc(){};
};
DWORD WINAPI A::MyThreadFunc(LPVOID lpParam) {
  A *a = static_cast<A*>(lpParam);
  return а->RealThreadFunc();
}

ExitThread is the preferred method of exiting a thread in C code. However, in C++ code, the thread is exited before any destructors can be called or any other automatic cleanup can be performed. Therefore, in C++ code, you should return from your thread function.

#include <iostream>
#include <chrono>
#include <thread>

class Dumb
{
private:
    int id;

public:
    Dumb(int _id)
        : id(_id)
    {

    }

    void stupid()
    {
        for (int i = 0; i < 10; i++)
        {
            using namespace std::chrono_literals;
            std::cout << id << " is thinking..." << std::endl;
            std::this_thread::sleep_for(1s);
        }
    }
};

int main()
{
    Dumb d1(1);
    std::thread t1(&Dumb::stupid, &d1);

    Dumb d2(2);
    std::thread t2(&Dumb::stupid, &d2);

    t1.join();
    t2.join();

    return 0;
}

return 0;

TerminateThread is a dangerous function that should only be used in the most extreme cases. You should call TerminateThread only if you know exactly what the target thread is doing, and you control all of the code that the target thread could possibly be running at the time of the termination. For example, TerminateThread can result in the following problems:
If the target thread owns a critical section, the critical section will not be released.
If the target thread is allocating memory from the heap, the heap lock will not be released.
If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state for the thread's process could be inconsistent.
If the target thread is manipulating the global state of a shared DLL, the state of the DLL could be destroyed, affecting other users of the DLL.

не будут вызваны деструкторы локальных объектов.

typedef struct
{
  // поля структуры;
  bool  terminate;
} MyData;

DWORD WINAPI  MyThreadFunc(LPVOID lpParam)
{
  MyData* pMyData = (*MyData)lpParam;
  // действия функции;
  if (pMyData->terminate==true)
  {
    // освобождение ресурсов;
    return 0;
  }
  // действия функции;
  if (pMyData->terminate==true)
  {
    // освобождение ресурсов;
    return 0;
  }
  // действия функции;
  return 0; // завершение работы функции MyThreadFunc
}

HANDLE hEvents[2];

DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
    DWORD dwEvent = 0;
    bool bExit = false;
    while (!bExit)
    {
        dwEvent = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
        switch (dwEvent)
        {
        case WAIT_OBJECT_0:    
            // событие на выход
            bExit = true;
            break;
        case WAIT_OBJECT_0 + 1:    
            //событие надо считать
            // тут идут какие-то расчёты
            break;
        default:
            // что-то пошло не так, выходим
            bExit = true;
        }
    }
    return dwEvent;
}
int main()
{
    hEvents[0] = CreateEvent(NULL, FALSE, FALSE, NULL);        // событие ожидается в потоке когда поток надо завершить
    hEvents[1] = CreateEvent(NULL, FALSE, FALSE, NULL);        // событие ожидается в потоке когда надо просыпаться и что-то считать
    
    DWORD tid = 0;
    CreateThread(NULL, 0, ThreadProc, NULL, 0, &tid);        // создаем рабочий поток
    SetEvent(hEvents[1]);                        // надо считать
    return 0;
}

RF>>typedef struct
RF>>{
RF>>  // поля структуры;
RF>>  bool  terminate;
RF>>} MyData;
С>...
RF>>

typedef struct
{
  // поля структуры;
  int workflag; // флаг: 0--поток выполняется, 1--завершить поток, 2--приостановить поток, 3--запустить на продолжение приостановленный поток
} MyData;

DWORD WINAPI  MyThreadFunc(LPVOID  lpParam)
{
  MyData *pMyData = (MyData*)lpParam;
  // действия функции;
  if (pMyData->workflag==1)
  // завершение потока
  {
    // освобождение ресурсов;
    return 0;
  }
  if (pMyData->workflag==2)
  // приостановка потока
  {
    // освобождение ресурсов, если необходимо;
    while ((pMyData->workflag!=1)&&(pMyData->workflag!=3)); // ждём, пока не появится команда завершить поток или продолжить выполнение потока
    if (pMyData->workflag==1)
    // завершение потока
    {
      // освобождение ресурсов;
      return 0;
    }
    if (pMyData->workflag==3)
    // продолжение исполнения потока
    {
      // подключить ресурсы, если необходимо;
      workflag = 0;
    }
  }
  // действия функции;
  if (pMyData->workflag==2)
  // приостановка потока
  {
    // освобождение ресурсов, если необходимо;
    while ((pMyData->workflag!=1)&&(pMyData->workflag!=3)); // ждём, пока не появится команда завершить поток или продолжить выполнение потока
    if (pMyData->workflag==1)
    // завершение потока
    {
      // освобождение ресурсов;
      return 0;
    }
    if (pMyData->workflag==3)
    // продолжение исполнения потока
    {
      // подключить ресурсы, если необходимо;
      workflag = 0;
    }
  }
  // действия функции;
  return 0; // завершение работы функции MyThreadFunc
}

if (pMyData->workflag==2)
// приостановка потока
{
  // освобождение ресурсов, если необходимо;
  while ((pMyData->workflag!=1)&&(pMyData->workflag!=3)); // ждём, пока не появится команда завершить поток или продолжить выполнение потока
  if (pMyData->workflag==1)
  // завершение потока
  {
    // освобождение ресурсов;
    return 0;
  }
  if (pMyData->workflag==3)
  // продолжение исполнения потока
  {
    // подключить ресурсы, если необходимо;
    workflag = 0;
  }
}

if (pMyData->workflag==2)
// приостановка потока
{
  // освобождение ресурсов, если необходимо;
  while ((pMyData->workflag!=1)&&(pMyData->workflag!=3))
  // ждём, пока не появится команда завершить поток или продолжить выполнение потока
  {
    Sleep(1000); // задержка выполнения потока на одну секунду, в функции Sleep можно поставить любое другое число
  }
  if (pMyData->workflag==1)
  // завершение потока
  {
    // освобождение ресурсов;
    return 0;
  }
  if (pMyData->workflag==3)
  // продолжение исполнения потока
  {
    // подключить ресурсы, если необходимо;
    workflag = 0;
  }
}

typedef struct
{
  volatile int flag;
} MyStruct;

class CCalcManDialog : public CDialogEx
{
  // данные и методы класса CCalcManDialog;
  MyStruct  myStruct;
  unsigned  threadID;
  HANDLE hThread;
  // методы и данные класса CCalcManDialog;
};

unsigned int __stdcall MyThreadFunc(void* pParam)
{
  int  i;
  MyStruct  *pMyStruct = (MyStruct*)pParam;
  volatile int  *pflag = &(pMyStruct->flag);

  for (i=0; i<20000; i++)
  {
    printf("i = %d\n",i);
    if (*pflag==0)
    {
      printf("The thread was terminated.\n"); // поток был принудительно завершён
      return 0;
    }
    if (*pflag==2) // поток был приостановлен
    {
        while ((*pflag!=0)&&(*pflag!=1))
            Sleep(1000);
        if (*pflag==0)
        {
            printf("The thread was terminated.\n"); // поток был принудительно завершён (после своей приостановки)
            return 0;
        }
    }
  }
  printf("The thread was finished successfully.\n"); // поток завершился благополучно (естественным образом)
  return 0;
}

BOOL CCalcManDialog::OnInitDialog()
{
    CDialog::OnInitDIalog();
    myStruct.flag = 1;
    hThread = (HANDLE)_beginthreadex(NULL,0,&MyThreadFunc,&myStruct,0,&threadID);
    return TRUE;
}

void CCalcManDialog::OnBnClickedOk()
// если была нажата клавиша "Выйти"
{
    myStruct.flag = 0;
    WaitForSingleObject(hThread,INFINITE);
    CloseHandle(hThread);
    CDialogEx::OnOk();
}

class  CCalcManDialog;

typedef struct
{
  CCalcManDialog *pCalManDialog;
  volatile int flag2;
} MyStruct2;

class CCalcManDialog : public CDialogEx
{
  // данные и методы класса CCalcManDialog;
  MyStruct2  myStruct2;
  unsigned  threadID2;
  HANDLE  hThread2;
  void  setTextIntoSTatic(char *s);
  CStatic  m_IDC_STATIC1;
  // данные и методы класса CCalcManDialog;
};

unsigned int __stdcall MyThreadFunc2(void* pParam)
{
  int  i;
  char s[50];
  bool localflag = true;
  MyStruct2 *pMyStruct2 = (MyStruct2*)pParam;
  CCalcManDialog *pCalcManDialog = pMyStruct->pCalcManDialog;
  volatile int *pflag2 = &(pmyStruct->flag2);

  while (localflag==true)
  {
    sprintf(s,"Расчёт выполняется");
    pCalcManDialog->setTextIntoStatic(s);
    Sleep(1000);
    sprintf(s,"Расчёт выполняется .");
    Sleep(1000);
    sprintf(s,"Расчёт выполняется . .");
    Sleep(1000);
    sprintf(s,"Расчёт выполняется . . .");
    Sleep(1000);
    if (*pflag2==0)
    {
        sprintf(s,"Расчёт выполнен");
        pCalcManDialog->setTextIntoStatic(s);
        localflag = false;
        break;
    }
    if (*pflag2==2)
    {
        while ((*pflag2!=0)&&(*pflag2!=1))
            Sleep(1000);
        if (*pflag2==0)
        {
            sprintf(s,"Расчёт выполнен");
            pCalcManDialog->setTextIntoStatic(s);
            localflag = false;
            break;
        }
    }
  }
  return 0;
}

void  CCalcManDialog::setTextIntoStatic(char *s)
{
    m_IDC_STATIC1.SetWindowsTextA(s);
}

BOOL  CCalcManDialog::OnInitDialog()
{
    CDialog::OnInitDialog();
    myStruct2.flag2 = 1;
    myStruct2.pCalcManDialog = this;
    hThread2 = (HANDLE)_beginthreadex(NULL,0,&MyThreadFunc2,&myStruct2,0,&threadID2);
    return TRUE;
}

void  CCalcManDialog::OnBnClickedOk()
{
    myStruct2.flag2 = 0;
    WaitForSingleObject(hThread2,INFINITE);
    CloseHandle(hThread);
    CDialogEx::OnOk();
}