In a previous article I showed how to get Visual C++ sample projects either by using Visual Studio IDE or by downloading from MSDN – Developer Code Samples site. Recently, I found that we can also download an archive containing a very large number of sample projects from GitHub. Pretty cool!
Here is the magic link: Microsoft – Windows Classic Samples.
C++ REST SDK (also known as Casablanca) offers support for HTTP client/server, JSON, URI, asynchronous streams, WebSockets client, oAuth and PPL Tasks.
We can get C++ REST SDK from CodePlex or use the one shipped with Visual Studio 2013.
This article gives suggestions of how to set up a Visual C++ project (particularly one that uses MFC) in order to be able to deal with Casablanca library. It also shows some simple sample code and a demo MFC project.
First, must find the location where C++ REST SDK is installed. With Visual Studio 2013 installed, I found it in the following path:
C:\Program Files (x86)\Microsoft SDKs\Cpp REST SDK for Visual Studio 2013\SDK\ which is similar to $(ExtensionSDKDirectoryRoot)\Cpp REST SDK for Visual Studio 2013\SDK.
Next, create a new MFC project or open an existing one, right click on it’s name, choose “Properties” from the context menu, then do the following:
Now, we are ready to go on and use C++ REST SDK stuff in our own MFC application.
Next is some code sample. You can notice it uses lambda expressions and for that reason I included this article in Using Lambdas in MFC Applications series.
This sample sends a JSON structure in URI query part to a site which gives in response also a JSON which says if the sent one is valid or not and gives an error description if necessary.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
void CJsonVerifierDlg::OnClickButtonVerifyJson() { UpdateData(); try { auto task = _VerifyJsonTask(); task.wait(); auto spJsonValue = task.get(); if (spJsonValue) _DisplayResponse(spJsonValue); } catch (std::exception& e) { CString strMessage; strMessage.Format(L"Exception: %S", e.what()); AfxMessageBox(strMessage, MB_ICONERROR); } } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
pplx::task<std::shared_ptr<web::json::value>> CJsonVerifierDlg::_VerifyJsonTask() { return pplx::create_task([this]() { // base URI auto sBaseURI = utility::string_t(m_strBaseURI.GetString()); // build request URI auto sRequestURI = web::http::uri_builder() .append_query(L"json", m_strInputJson.GetString()).to_string(); // create http client web::http::client::http_client httpClient(sBaseURI); // create GET http request web::http::http_request httpRequest(U("GET")); //web::http::methods::GET); // set request URI httpRequest.set_request_uri(sRequestURI); // send request return httpClient.request(httpRequest); // then receive the response }).then([](web::http::http_response httpResponse) { std::shared_ptr<web::json::value> spJsonValue; if (web::http::status_codes::OK == httpResponse.status_code()) { spJsonValue = std::make_shared<web::json::value>(httpResponse.extract_json().get()); } return spJsonValue; }); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
void CJsonVerifierDlg::_DisplayResponse(const std::shared_ptr<web::json::value>& spJsonValue) { if ((*spJsonValue)[U("validate")].as_bool()) { m_strIsValid = _T("YES"); m_nParseTime = (*spJsonValue)[U("parse_time_nanoseconds")].as_integer(); } else { m_strIsValid = _T("NO"); m_strError = (*spJsonValue)[U("error")].as_string().c_str(); } UpdateData(FALSE); } |
More details about project settings and source code can be found in the attached demo project.
Download: JSON Verifier - Demo Application using Casablanca.zip (1748)
JSON Verifier – Demo Application using Casablanca
According to C++11 Standard, stateless lambdas, i.e. having an empty lambda introducer or capture no variables, are implicitly convertible to function pointers. Visual C++ in Visual Studio 2012 and newer, supports this feature. Moreover, in Visual C++ stateless lambdas are convertible to function pointers with arbitrary calling conventions. This is great if have to deal with Win32 API functions, most of them using __stdcall calling convention.
Let’s begin with two simple examples of enumerating top-level windows, one by using a callback function and the other by using a lambda expression.
Usually, for that purpose we declare and implement as callback, a static member function having the signature required by EnumWindows in its first argument.
|
1 2 3 4 5 6 |
class CDemoDlg : public CDialog { // ... static BOOL CALLBACK EnumWindowsProc(HWND hWnd, LPARAM lParam); }; |
|
1 2 3 4 5 6 7 8 9 10 11 |
BOOL CALLBACK CDemoDlg::EnumWindowsProc(HWND hWnd, LPARAM lParam) { CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam); // do something, e.g. add the found window handle to a list return TRUE; // continue the enumeration } void CDemoDlg::OnButtonEnumWindows() { ::EnumWindows(&CDemoDlg::EnumWindowsProc, reinterpret_cast<LPARAM>(this)); } |
The same result can be achieved by using a lambda expression. This is somehow simpler because does not require to declare and define a static member function.
|
1 2 3 4 5 6 7 8 9 10 11 |
void CDemoDlg::OnButtonEnumWindows() { // in the first parameter of EnumWindows, pass a lambda expression ::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL { CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam); // do something, e.g. push the found window handle in a list. return TRUE; // continue the enumeration }, reinterpret_cast<LPARAM>(this)); // second parameter of EnumWindows } |
Let’s say we want to enumerate the top-level windows in a worker thread. We can write something like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
void CDemoDlg::OnButtonEnumWindows() { AfxBeginThread([](LPVOID lpParam) -> UINT { ::EnumWindows([](HWND hWnd, LPARAM lParam) -> BOOL { CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam); // do something, e.g. push the found window handle in a list return TRUE; // continue the enumeration }, reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows return 0; }, reinterpret_cast<LPVOID>(this)); // second parameter of AfxBeginThread } |
We have passed lambdas both for callback parameter of AfxBeginThread and EnumWindows. EnumWindows is called in the first lambda body and takes a lambda as well.
This compiles with no problem in x64 builds, but may give a conversion error for the inner lambda in Win32 ones. That’s a little glitch which AFAIK has been fixed in Visual Studio 2015.
However, to be sure it compiles also in Visual Studio 2012/2013 – Win32 builds, we can simply cast explicitly the inner lambda.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
void CDemoDlg::OnButtonEnumWindows() { AfxBeginThread([](LPVOID lpParam) -> UINT { ::EnumWindows(static_cast<WNDENUMPROC>([](HWND hWnd, LPARAM lParam) -> BOOL { CDemoDlg* pDlg = reinterpret_cast<CDemoDlg*>(lParam); // do something, e.g. push the found window handle in a list return TRUE; // continue the enumeration }), reinterpret_cast<LPARAM>(lpParam)); // second parameter of EnumWindows return 0; }, reinterpret_cast<LPVOID>(this)); // second parameter of AfxBeginThread } |
Beginning with Visual Studio 2010 which supports lambda expressions introduced by C++11 standard, you can handily sort an MFC array like in the following example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Example #1 // ... CStringArray arr; arr.Add(_T("John")); arr.Add(_T("Zorro")); arr.Add(_T("Sandy")); arr.Add(_T("Jimmy")); // ... bool bAscending = true; // ... std::sort( arr.GetData(), // position of first element arr.GetData() + arr.GetSize(), // position one past the final element [bAscending] // lambda introducer (const CString& left, const CString& right) // lambda formal parameters list { return bAscending ? (left < right) : (left > right); } // lambda body ); // ... |
Of course, you can write similar code for other types of MFC arrays like CArray, CUIntArray, and so on.
But also you can easily write a kind of “generic lambda” in order to sort any type of MFC arrays.
|
1 2 3 4 5 6 7 8 9 10 |
// Example #2 // ... std::sort( arr.GetData(), arr.GetData() + arr.GetSize(), [bAscending] (decltype(*arr.GetData()) left, decltype(*arr.GetData()) right) { return bAscending ? (left < right) : (left > right); } ); // ... |
That’s pretty cool… However would be nice to be possible to get rid of “wordy” constructions like “decltype(*arr.GetData())” in the lambda’s formal parameters list. Good news! There is a proposal for next C++ standards: using auto type-specifier in order to make generic lambda expressions (which accept any type of arguments). And that is already supported in Visual Studio 2015.
|
1 2 3 4 5 6 7 8 |
// Example #3 std::sort( arr.GetData(), arr.GetData() + arr.GetSize(), [bAscending] (auto left, auto right) { return bAscending ? (left < right) : (left > right); } ); |
Latest versions of Visual Studio come with few or no source code project samples. However, there are hundreds available on Microsoft sites. Here is how to get them.
For getting samples from Visual Studio IDE, follow next steps:
Get Visual C++ samples – step 1
If you have Visual Studio 2012 or Visual Studio 2013, the New Project dialog is open.
Get Visual C++ samples – step 2
Get Visual C++ samples – step 3
Now, the sample project is added to the installed samples list, which are available each time you want to have a look inside.
Installed samples
Additionally, each time when open an installed sample project, Visual Studio shows a page containing the sample description, a link to download page, plus links to useful resources and tutorials. That’s pretty cool but notice that Visual Studio gets only the samples written for its own version. To get access to all samples, see the next method.
Here is the magic link: http://code.msdn.microsoft.com/
Click it here or type in a browser and get the main Developer Code Samples page. You can filter the articles according to your interests (programming language: C++, platform: Desktop and so on). Moreover, you can type a keyword to refine the filter (e.g. Direct2D) like in the below picture.
Developer Code Samples page
All to do next is to click on desired link and download.
Visual Studio 2010 Samples
Nice to have a look: old programmers to remember, the young ones to see how Microsoft Visual C++ was born.
Visualize Your Masterpiece: Microsoft Visual C++ 1.0 Launch