郑君的学习笔记

BOOL CMRLGaugerDrawerDlg::PreTranslateMessage(MSG* pMsg)
{
	if (pMsg->message == WM_KEYDOWN)
	{
		if (pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE)
		{
			// Do not process further
			return TRUE;                
		}
	}

	return CDialogEx::PreTranslateMessage(pMsg);
}

if (IDYES == AfxMessageBox(L"即将删除所有标记的测量点，请再次确认该操作。",MB_YESNO))
{
    // do something
}

BOOL CMRLGaugerDrawerDlg::PreTranslateMessage(MSG* pMsg)
{
	if (pMsg->message == WM_KEYDOWN)
	{
		if (pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE)
		{
			// Do not process further
			return TRUE;                
		}
	}

	return CDialogEx::PreTranslateMessage(pMsg);
}

if (IDYES == AfxMessageBox(L"即将删除所有标记的测量点，请再次确认该操作。",MB_YESNO))
{
    // do something
}

// 发送队列锁
std::mutex m_mutex_write;
std::unique_lock guard(m_mutex_write);
// 可以在 guard 生命周期结束前解锁
guard.unlock();
// 解锁后还可以再次加锁
guard.lock();

/// 实例容器锁
mutable std::mutex mutMapInst;

{
    std::lock_guard<std::mutex>lk(m_devInfo.mutMapInst);
    m_devInfo.mapInst.emplace(make_pair(instId, &dev));
}

CMutex Mutex;

CSingleLock SingleLock(&Mutex);
SingleLock.Lock();

CRITICAL_SECTION cs;

InitializeCriticalSection(&m_curInfo.cs);

EnterCriticalSection(&m_curInfo.cs);
m_curInfo.timeCmp = time(NULL);
LeaveCriticalSection(&m_curInfo.cs);

DeleteCriticalSection(&m_curInfo.cs);

// 同步发送数据的，读取完毕后，在发送
HANDLE m_hEvent_write;

m_hEvent_write = CreateEvent(
		NULL,               // default security attributes
		TRUE,               // manual-reset event
		FALSE,              // initial state is nonsignaled
		TEXT("WriteEvent")  // object name
	);

WaitForSingleObject(pwnd->m_hEvent_write, INFINITE);
// go on
::SetEvent(m_hEvent_write);

CloseHandle(m_hEvent_write)

if (false == m_thread_recive.joinable())
{
	m_thread_recive = std::thread(threadReceive, this);
}

int threadReceive(const void* p)
{
	CTcpClient* pwnd = (CTcpClient*)p;
	while (FLAG_EXIT_THREAD_RECEIVE != (pwnd->m_flag&FLAG_EXIT_THREAD_RECEIVE))
	{


		for (int i = 0; i < 20; ++i)
		{
			if (FLAG_EXIT_THREAD_RECEIVE == (pwnd->m_flag&FLAG_EXIT_THREAD_RECEIVE))
			{
				goto skip_return;
			}
			this_thread::sleep_for(chrono::milliseconds(100));
		}
	}
skip_return:
	return 0;
}

// Create a thread using member function
std::thread th(&Task::execute, taskPtr, "Sample Task");

std::thread m_threadHttpServer;

if (FLAG_HTTP_SERVER_RUNNING != (g_iFlag&FLAG_HTTP_SERVER_RUNNING))
{
  m_threadHttpServer = std::thread(threadHttpServer, (this), 2,"other param");
}

g_iFlag |= FLAG_EXIT_HTTP_SERVER;
while (FLAG_HTTP_SERVER_RUNNING == (g_iFlag&FLAG_HTTP_SERVER_RUNNING))
{
  Sleep(200);
}

if (m_threadHttpServer.joinable())
{
  m_threadHttpServer.join();
}
g_iFlag &= (~FLAG_EXIT_HTTP_SERVER);

// thread example
#include <iostream>       // std::cout
#include <thread>         // std::thread


		str.Format(L"foo %d\n", i);
		OutputDebugString(str);
		Sleep(1000);
	}
}

void bar(int& x, int& out)
{
	int m = 0;
	CString str;
	for (int i = 0; i < 5; ++i)
	{
		m += x;
		str.Format(L"bar %d\n", i);
		OutputDebugString(str);
		Sleep(1000);
	}
	out = m;
}

int main()
{
  CString str;

	std::thread first(foo);     // spawn new thread that calls foo()
	int out = 0;
	int in = 10;
	std::thread second(bar, ref(in),ref(out));  // spawn new thread that calls bar(0)

	OutputDebugString(L"main, foo and bar now execute concurrently...\n");

	// synchronize threads:
	first.join();                // pauses until first finishes
	second.join();               // pauses until second finishes


	str.Format(L"foo and bar completed. out:%d\n", out);

	OutputDebugString(str);

  return 0;
}

public slots:
	void onBtn_driver_config();

void QtGuiApplication1::onBtn_driver_config()
{
	QMessageBox::information(NULL, "info", "onBtn_driver_config", QMessageBox::Ok);
}