BOOL WINAPI CreateProcess(
  _In_opt_    LPCTSTR               lpApplicationName,      // const char*
  _Inout_opt_ LPTSTR                lpCommandLine,          // char*
  _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,
  _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,     // 
  _In_        BOOL                  bInheritHandles,
  _In_        DWORD                 dwCreationFlags,
  _In_opt_    LPVOID                lpEnvironment,
  _In_opt_    LPCTSTR               lpCurrentDirectory,
  _In_        LPSTARTUPINFO         lpStartupInfo,
  _Out_       LPPROCESS_INFORMATION lpProcessInformation
);

HANDLE CreateRemoteThreadEx(
  __in__ HANDLE                       hProcess,
  __in__ LPSECURITY_ATTRIBUTES        lpThreadAttributes,
  __in__ SIZE_T                       dwStackSize,
  __in__ LPTHREAD_START_ROUTINE       lpStartAddress,
  __in__ LPVOID                       lpParameter,
  __in__ DWORD                        dwCreationFlags,
  __in__ LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList,
  __out__ LPDWORD                     lpThreadId
);

DWORD WINAPI FormatMessage(
   _In_     DWORD dwFlags,
   _In_opt_ LPCVOID lpSource,
   _In_     DWORD dwMessageId,
   _In_     DWORD dwLanguageId,
   _Out_    LPTSTR lpBuffer,
   _In_     DWORD nSize,
   _In_opt_ va_list *Arguments
);

#include <sal.h>     // Microsft's Source Code Annotation Language 
#include <iostream>

// Computes elementwise product of two vectors 
void vector_element_product(
      _In_ size_t size,
      _In_ const double xs[],
      _In_ const double ys[],
      _Out_      double zs[]
      ){
      for(int i = 0; i < size; i++){
          zs[i] = xs[i] * ys[i];
      }
}

void showArray(size_t size, double xs[]){
  std::cout << "(" << size << ")[ ";
  for(int i = 0; i < size; i++){
    std::cout << xs[i] << " ";
  }
  std::cout << "] ";
}

int main(){
  double xs [] = {4, 5, 6, 10};
  double ys [] = {4, 10, 5, 25};
  double zs [4];
  vector_element_product(4, xs, ys, zs);
  std::cout << "xs = "; showArray(4, xs); std::cout << "\n";
  std::cout << "ys = "; showArray(4, ys); std::cout << "\n";
  std::cout << "zs = "; showArray(4, zs); std::cout << "\n";
  
}

#ifdef _UNICODE
  typedef wchar_t TCHAR;
#else
  typedef char TCHAR;
#endif

#ifdef _UNICODE 
   #define _T(str)   L##str
   #define TEXT(c)   L##str
#else 
   #define _T(str)     str 
   #define TEXT(str)   str
#endif

"UTF8 - Unicode 8 bits multi-byte literal";
// Note: It doesn't work with Windows APIs (Windows specific functions)
char utf8_text [] = "Random text in Chinese script (UTF8): 读写汉字1";

L"UTF16 Wchar wide chracters literal";
wchar_t utf16_text [] = L"Random text in Chinese script (UTF16): 读写汉字1";

TCHAR text [] = _T("Random text in Chinese script  读写汉字1");
// OR 
TCHAR text [] = TEXT("Random text in Chinese script  读写汉字1");

char text [] = "Random text in Chinese script 读写汉字1";

wchar_t text [] = L"Random text in Chinese script 读写汉字1";

BOOL CreateDirectoryA(
  LPCSTR /* const char */  lpPathName,
  LPSECURITY_ATTRIBUTES    lpSecurityAttributes
);

BOOL CreateDirectoryW(
  LPCWSTR /* const wchar_t*  */  lpPathName,   
  LPSECURITY_ATTRIBUTES          lpSecurityAttributes
);

size_t wcslen (const wchar_t* wcs);

wchar_t* wcscpy (wchar_t* destination, const wchar_t* source);

wchar_t* wcscat (wchar_t* destination, const wchar_t* source

#include <fstream> 
#include <string>
#include <sstream>

// Enable Unicode version of Windows API compile with -DWITH_UNICODE 
#ifdef WITH_UNICODE
  #define UNICODE
  #define _UNICODE
#endif 

#include <windows.h>
#include <tchar.h>

// ===========> EXPERIMENT 1 - Print to Console ============//	
std::cout << "\n ===>>> EXPERIMENT 1: Print to terminal [ANSI/UTF8] <<<=== " << std::endl;
{
   std::cout  <<  " [COUT] Some text example - указан - 读写汉字1 " << "\n";
   std::wcout << L" [WCOUT] Some text example - указан - 读写汉字1 " << L"\n";	
}

// ===========> EXPERIMENT 2 - Print to File ============//
std::cout << "\n ===>>> EXPERIMENT 2: Write non ANSI Chars to File <<<=== " << "\n";
std::stringstream ss;
ss << " Text in Cyrllic Script: Если указан параметр  " << "\n"
   << " Text in Chinese Script: 读写汉字1 " << "\n"
   << "\n";

auto dfile = std::ofstream("logging.txt");
dfile << ss.str() << std::flush;

   // ===========> EXPERIMENT 4 - WinAPI - CreateDirectory ============//
   std::cout << "\n ===>>> EXPERIMENT 3: WinAPI CreateDirectory <<<=== " << std::endl;

   { // -- ANSI Version of CreateDirectory API 
       bool res;
       res = CreateDirectoryA("directoryANSI-读写汉字1", NULL);
       std::cout << "Successful 1 ?=  " << std::boolalpha << res << std::endl;
   }

   {  // -- Unicode (UTF16) - Wide character version of CreateDirectory API 
       bool res;
       res = CreateDirectoryW(L"directoryWCHAR-读写汉字", NULL);
       std::cout << "Successful 2 ?= " << std::boolalpha << res << std::endl;  		
   }
   {
      // -- TCHAR Version Wide character version of CreateDirectory API 
      bool res;

      #ifdef UNICODE
        std::cout << " [INFO] UNICODE (UTF16) CreateDirectory expanded to CreateDirectoryW" << std::endl;
      #else
        std::cout << " [INFO] ANSI CreateDirectory expanded to CreateDirectoryA" << std::endl;
      #endif
      res = CreateDirectory(_T("directoryTCHAR-读写汉字"), NULL);
      std::cout << "Successful 3 ?= " << std::boolalpha << res << std::endl;  		
}

// ===========> EXPERIMENT 4 - WinAPI - MessageBox ============//
std::cout << "\n ===>>> EXPERIMENT 4: MessageBox <<<=== " << std::endl;

DWORD const infoboxOptions  = MB_OK | MB_ICONINFORMATION | MB_SETFOREGROUND;
// Text in UTF8 => Note => Windows API doesn't work with UTF8
// or multi-byte characters as the API treats the chars as they were ANSI.
char narrowText []  = "Some chinese text não inglês  读写汉字 - 学中文";
// Unicode text in UTF16 
wchar_t wideText []  = L"Some chinese text não inglês 读写汉字 - 学中文";
MessageBoxA( 0, narrowText, "ANSI (narrow) text:", infoboxOptions );    
MessageBoxW( 0, wideText, L"Unicode (wide) text:", infoboxOptions );

auto utf8_encode(const std::wstring &wstr) -> std::string
{
    int size_needed = WideCharToMultiByte(
            CP_UTF8, 0, &wstr[0],
            (int)wstr.size(), NULL, 0, NULL, NULL);
    std::string strTo(size_needed, 0);
    WideCharToMultiByte(
            CP_UTF8, 0, &wstr[0],
            (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
    return strTo;
}

// Convert an UTF8 string to a wide Unicode String
// Credits: https://gist.github.com/pezy/8571764
auto utf8_decode(const std::string &str) -> std::wstring
{
     int size_needed = MultiByteToWideChar(
             CP_UTF8, 0,
             &str[0], (int)str.size(), NULL, 0);
     std::wstring wstrTo(size_needed, 0);
     MultiByteToWideChar(
             CP_UTF8, 0, &str[0],
             (int) str.size(), &wstrTo[0], size_needed);
     return wstrTo;
}

 // Requires: <windows.h>, <winbase.h> and <Lmcons.h>
auto getUserName() -> std::string
{
    DWORD size = UNLEN + 1;
    std::wstring buffer(size, 0x00);
    //BOOL GetUserNameW(LPWSTR lpBuffer, LPDWORD pcbBuffer);
    GetUserNameW(&buffer[0], &size);
    buffer.resize(size - 1);
    return utf8_encode(buffer);
}

auto messageBox(const std::string& title, const std::string& text) -> void 
{
    DWORD const infoboxOptions  =
            MB_OK | MB_ICONINFORMATION | MB_SETFOREGROUND;
    ::MessageBoxW(
            0
            ,utf8_decode(text).c_str()
            ,utf8_decode(title).c_str()
            ,infoboxOptions
            );
}

std::cout << "USER NAME = " << getUserName() << std::endl;

std::string message = "Text with unicode UTF8 - 读写汉字1 - Если указан параметр ";
std::string title   = "Title in UTF8 الْحُرُوف الْعَرَبِيَّة";	
messageBox(title, message);	
return 0;

// Uses RAII for setting console to UTF8
// and restoring its previous settings.
class ConsoleUTF8{
public:
   // Constructor saves context 
   ConsoleUTF8(){
       m_config = ::GetConsoleOutputCP();
       ::SetConsoleOutputCP(CP_UTF8);
       std::perror(" [TRACE] Console set to UTF8");
   }
   // Destructor restores context 
   ~ConsoleUTF8(){
      std::perror(" [TRACE] Console restored.");
      ::SetConsoleOutputCP(m_config);
   }
private:
   unsigned int m_config;
};

struct ExitPrompt{
    ~ExitPrompt(){
        std::puts(" >>> Enter RETURN to exit");
        std::cin.get();
    }
};

#ifdef UTF8
auto utf8Console = ConsoleUTF8();
#endif 
//auto codePage = ::SetConsoleOutputCP(CP_UTF8);

auto exitPrompt = ExitPrompt();
std::puts("Testing Console output with UTF8");
std::puts("--------------------------------");

std::puts("Text with UTF8 - SÃO JOÃO -  ");
std::puts("Japanese Kanji - 漢字 ; Japanese Hiragrama - 平仮名 ");
std::puts("Cyrllic Script - Sputnik = Спутник-1");
std::puts("Greek/Latin Script = Α α, Β β, Γ γ, Δ δ, Ε ε, Ζ ζ, Η η, Θ θ");

//::SetConsoleOutputCP(codePage);
return 0;

// Compile and run with UTF8 flag disabled 
$ cl.exe console-utf8.cpp /EHsc /Zi /nologo /Fe:out.exe && out.exe

  // Compile and run with UTF8 flag disabled // Compile run with UTF8 flag enabled  
$ cl.exe console-utf8.cpp /EHsc /Zi /nologo /Fe:out.exe -DUTF8 && out.exe

// Compile and run with UTF8 flag disabled 
 g++ console-utf8.cpp -o out-gcc.exe -std=c++14 -Wall && out-gcc.exe
// Compile and run with UTF8 flag disabled 
 g++ console-utf8.cpp -o out-gcc.exe -std=c++14 -Wall -DUTF8 && out-gcc.exe

=========== Current Process Info ========
PID              = 6916
hProc            = 0x00007FF72C300000
Executable path  = C:\Users\archbox\Desktop\experiments\currentProcess.exe
Current path     = C:\Users\archbox\Desktop\experiments

 ==> Type RETURN to exit.

// Return true if program was launched by clicking on it, 
// return false if this program was launched from command line.
auto isInOwnConsole() -> bool {
     DWORD procIDs[2];
     DWORD maxCount = 2;
     DWORD result = GetConsoleProcessList((LPDWORD)procIDs, maxCount);
     return result != 1;
}

auto ExecutablePath = [](int pid){
     HANDLE hProc = OpenProcess( PROCESS_QUERY_INFORMATION
                                | PROCESS_VM_READ, FALSE, pid );
     // Get process file path 
     std::string process_path(MAX_PATH, 0);
     DWORD size = MAX_PATH; 
     QueryFullProcessImageNameA(hProc, 0, &process_path[0], &size);
     process_path.resize(size);	
     CloseHandle(hProc);
     return process_path;
};

auto CurrentDirectory = []{
     DWORD size = ::GetCurrentDirectory(0, nullptr);
     assert(size != 0);
     std::string path(size + 1, 0x00);
     size = ::GetCurrentDirectory(path.size(), &path[0]);
     path.resize(size);
     return path;
};

// Get current process ID 
DWORD    pid   = GetCurrentProcessId();
// Return module handle of current process 
HMODULE  hProc = GetModuleHandleA(nullptr);
// Get process module
std::cout << "=========== Current Process Info ========"  << std::endl;
std::cout << "PID              = " << pid                 << std::endl;
std::cout << "hProc            = 0x" << hProc             << std::endl;
std::cout << "Executable path  = " << ExecutablePath(pid) << std::endl;
std::cout << "Current path     = " << CurrentDirectory()  << std::endl;

// Copy itself to Desktop
CopyFile(ExecutablePath(pid).c_str(), "C:\\Users\\archbox\\Desktop\\appinfo.exe", false) ;

// Stop program from exiting if it was launched by clicking on it.
if(!isInOwnConsole()){
        std::cout << "\n ==> Type RETURN to exit." << std::endl;
        std::cin.get();
}	
return EXIT_SUCCESS;

// Show all processes in current machine
auto showProcessInfo(std::ostream& os) -> int {
  // Get snapshot with process listing.
  HANDLE hProcessSnapShot =
    CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  
  // Instnatiate process' entry structure.
  PROCESSENTRY32 ProcessEntry = { 0 };
  ProcessEntry.dwSize = sizeof( ProcessEntry );
  BOOL Return = FALSE;
  Return = Process32First( hProcessSnapShot, &ProcessEntry );
  // Returns -1 if process failed 
  if(!Return ) {  return -1;}
  do { // print process' data
      os << "EXE File     = " << ProcessEntry.szExeFile      << "\n"
         << "PID          = " << ProcessEntry.th32ProcessID  << "\n"
         << "References   = " << ProcessEntry.cntUsage       << "\n"
         << "Thread Count = " << ProcessEntry.cntThreads     << "\n"  
         << "-----------------------------------------------\n";
    }
  while( Process32Next( hProcessSnapShot, &ProcessEntry ));
  // Close handle releasing resource.
  CloseHandle( hProcessSnapShot );
  return 1;
}

// Log file 
auto plog = std::ofstream("process-log.txt");
// Print all processes to stdout. 
showProcessInfo(std::cout);
// Write all processes to file 
showProcessInfo(plog);
// Flush buffer - force data to be written to file.
plog.flush();

std::cout << "\n ==> Type return to exit." << std::endl;
std::cin.get();
return 0;

# Build 
$ cl.exe showProcesses.cpp /EHsc /Zi /nologo /Fe:showProcesses.exe  

# Run: 
$ showProcesses 
# Run 
$ showProcesses.exe 

template<class HANDLER>
class ResourceHandler
{
public:
    using Disposer = std::function<void (HANDLER)>;
    ResourceHandler(HANDLER hnd, Disposer disposer)
       : m_hnd(hnd), m_fndisp(disposer)
    {  }
    auto get() -> HANDLER {
       return m_hnd;
    }
    ~ResourceHandler(){
       m_fndisp(m_hnd);
    }
    // Disable copy-constructor and copy-assignment operator 
    ResourceHandler(const ResourceHandler&) = delete;
    auto operator= (const ResourceHandler&) -> ResourceHandler& = delete;
    // Move member functios
    ResourceHandler(ResourceHandler&& rhs)
     : m_hnd(rhs.m_hnd),
       m_fndisp(rhs.m_fndisp){ }
    auto operator= (ResourceHandler&& rhs){
        std::swap(this->m_hnd, rhs.m_hnd);
        this->m_fndisp = rhs->m_fndisp;		
    }
private:
    HANDLER m_hnd;
    Disposer m_fndisp;
};

namespace WProcess{
     using ModuleConsumer = std::function<auto (HMODULE, const std::string&) -> void>;	
     auto GetName(HANDLE hProc) -> std::string;
     auto GetExecutablePath(HANDLE hProc) -> std::string;
     auto ForEachModule(HANDLE hProc, ModuleConsumer FunIterator) -> void;
}

DWORD pid;
DWORD  flags = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ;

try{
    pid  = std::stoi(argv[1]);
} catch(const std::invalid_argument& ex){
    std::cerr << "Error invalid PID" << std::endl;
    return EXIT_FAILURE;
}  
  
// Automatically closes this handle when it goes out of scope.
auto hProc = ResourceHandler<HANDLE>{
    ::OpenProcess(flags, FALSE, pid),
    ::CloseHandle
};

std::cout << "Process base name = "
          << WProcess::GetName(hProc.get())
          << std::endl; 

std::cout << "Process path      = "
          << WProcess::GetExecutablePath(hProc.get())
          << std::endl;

using ModuleConsumer = std::function<auto (HMODULE, const std::string&) -> void>;  

// Print all DLLs used by some process 
WProcess::ForEachModule(
	  hProc.get(),
	  [](HMODULE hmod, const std::string& path) -> void
	  {
           std::cout << std::setw(10) << hmod
                     << std::setw(5)  << " "
                     << std::left     << std::setw(45) << path
                     << "\n";					
	  }
	  );

auto GetName(HANDLE hProc) -> std::string {
      std::wstring basename(MAX_PATH, 0);
      int n1 = ::GetModuleBaseNameW(hProc, NULL, &basename[0], MAX_PATH);
      basename.resize(n1);
      return utf8_encode(basename);
}

auto GetExecutablePath(HANDLE hProc) -> std::string {
     std::wstring path(MAX_PATH, 0);
     int n2 = ::GetModuleFileNameExW(hProc, NULL, &path[0], MAX_PATH);
     path.resize(n2);
     return utf8_encode(path);
}

auto ForEachModule(HANDLE hProc, ModuleConsumer FunIterator) -> void {
     HMODULE hMods[1024];
     DWORD   cbNeeded;
     if (::EnumProcessModules(hProc, hMods, sizeof(hMods), &cbNeeded)){
            int n = cbNeeded / sizeof(HMODULE);
            std::wstring path(MAX_PATH, 0);
            for(int i = 0; i < n; i++){
                DWORD nread = ::GetModuleFileNameExW(hProc, hMods[i], &path[0], MAX_PATH);
                path.resize(nread);		
                if(nread) FunIterator(hMods[i], utf8_encode(path));
            }
     }	
}

$ cl.exe listFiles.cpp /EHsc /Zi /nologo /Fe:listFiles.exe 

$ g++ listFiles.cpp -o listFiles.exe -std=c++14 

// Print human-readable description of GetLastError() - Error Code
// Source: https://stackoverflow.com/questions/1387064 Requires:
// <string>, <sstream>, <windows.h>,
auto getLastErrorAsString() -> std::string {
    //Get the error message, if any.
    DWORD errorMessageID = ::GetLastError();
    if(errorMessageID == 0)
        return std::string();
    LPSTR messageBuffer = nullptr;
    static const DWORD flags  =
      FORMAT_MESSAGE_ALLOCATE_BUFFER
      | FORMAT_MESSAGE_FROM_SYSTEM
      | FORMAT_MESSAGE_IGNORE_INSERTS;
    size_t size = FormatMessageA(
                flags,
                NULL,
                errorMessageID,
                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                (LPSTR)&messageBuffer, 0, NULL);
    auto message = std::string(messageBuffer, size);
        auto ss = std::stringstream(message);
        auto line = std::string{};
        std::getline(ss, line, '\r');
    //Free the buffer.
    LocalFree(messageBuffer);
    return line;  
}

 using FileEnumerator = std::function<bool (const std::string&)>;

/** Enumerate files of some directory util enumerator function (callback) returns false. 
  * - path       - Directory path to be listed 
  * - Enumerator - Functions which consumes a string (file listed) and returns bool.
  *                this function returns false when it is no longer interested in 
  *                being called. When it returns false the iteration stops. 
  *
  * - Return    - Returns error code from GetLastError(). If it is successful, 
  *               the function returns ERROR_SUCCESS.
  */
auto EnumerateFiles(const std::string& path, FileEnumerator Enumerator) -> int {
     WIN32_FIND_DATAW fdata;
     HANDLE hFind = INVALID_HANDLE_VALUE;
     // Ensure that resource hFind is always disposed. 
     auto close_hFind = CloseHandleRAAI(std::bind(CloseHandleLog, hFind, "hFile"));
     hFind = FindFirstFileW(utf8_decode(path).c_str(), &fdata);
     if(hFind == INVALID_HANDLE_VALUE)
             return GetLastError();
     do { //Consumer function 
             if(!Enumerator(utf8_encode(fdata.cFileName))) break;
     } while(FindNextFileW(hFind, &fdata) != 0);
     return ERROR_SUCCESS;
}

if(argc < 2){
    std::cerr << "Usage: " << argv[0] << " " << "[PATH]" << std::endl;
    return EXIT_FAILURE;
}
auto utf8Console = ConsoleUTF8();
auto directoryPath = std::string{argv[1]};
std::cout << "directoryPath = " << directoryPath << "\n";
int count = 0;	
// Show 50 first files. 
int status = EnumerateFiles(
    directoryPath,
    [&count](const auto& file){
            std::cout << " => " << file << "\n";
            if(count++ < 50)
                    return true;
            else
                    return false;
    });
if(status != ERROR_SUCCESS){
     std::cout << " => Error code    = " << ::GetLastError() << std::endl;
     std::cout << " => Error message = " << getLastErrorAsString() << std::endl;
     return EXIT_FAILURE;
}	
std::puts(" [LOG] End sucessfully");
return EXIT_SUCCESS;

std::puts("Logical Drivers or Disks found in the current installation");
std::puts("------------------------------------------------");

EnumerateLogicalDriver(
        [](const std::string& name){
                std::cout << "Driver = " << name << std::endl;
        });

auto driverList1 = LogicalDriverList<std::deque>();
std::cout << " *=> Driver list in STL container std::deque  = ";
for(const auto& d: driverList1){ std::cout << d << ", "; }
std::cout << std::endl;;

auto driverList2 = LogicalDriverList<std::vector>();
std::cout << " *=> Driver list in STL container std::vector = ";
for(const auto& d: driverList2){ std::cout << d << ", "; }
std::cout << std::endl;;

return 0;

using DriverEnumerator = std::function<auto (std::string) -> void>;

auto EnumerateLogicalDriver(DriverEnumerator Consumer) -> void 
{
    size_t size = ::GetLogicalDriveStringsA(0, nullptr);
    std::string buffer(size, 0x00);
    ::GetLogicalDriveStringsA(buffer.size(), &buffer[0]);
    std::stringstream ss{buffer};
    while(std::getline(ss, buffer, '\0') && !buffer.empty())
         Consumer(buffer);
}

// Remember: Template always in header files The user can choose the
// type of container used to return the computer drivers.
template<template<class, class> class Container = std::vector>
auto LogicalDriverList()
        -> Container<std::string, std::allocator<std::string>>
{	
    Container<std::string, std::allocator<std::string>> list{};
    EnumerateLogicalDriver(
            [&](const std::string& name){
                    list.push_back(name);
            });
    return list;	
}

int main(int argc, char** argv){
    if(argc < 2){
        std::cerr << "Usage: " << argv[0] << " [test0 | test1 | test2 | test3 | test4 ]" << std::endl;
        return EXIT_FAILURE;
    }
    auto tryExit = [&argc, &argv](std::function<int ()> Action) -> void {
         try {
             // End current process with exit code returned
             // from function
             int status = Action();			
             std::cerr << "[SUCCESS] End gracefully";
             std::exit(status);
         } catch(const std::runtime_error& ex)
         {
              std::cerr << "[ERROR  ] " << ex.what() << std::endl;
              std::exit(1);
         }		
    };

   /** Stream process output to stdout line by line. Print line read form subprocess 
    * output as soon as it arrives. */
   if(std::string(argv[1]) == "test0")
       tryExit([]{
               auto p = ProcessBuilder();
               p.SetProgram("ping 8.8.8.8");				
               std::puts("Stream output of process ping to stdout.");
               p.StreamLines([](std::string line){
                      std::cout << " line = " << line << std::endl;
                      return true;
                   });
               return EXIT_SUCCESS;
           });     

  /** Read whole process output and then print it to console and to a file. 
     * run $ dir . at path C:\\windows\\system32, read the whole process output 
     * as string printing it and saving it to a log file. (output.log)
     */
   if(std::string(argv[1]) == "test1")
     ... ... ... ... 
  
    std::cerr << "Error: invalid option " << std::endl;	
    return EXIT_FAILURE;
   }

if(std::string(argv[1]) == "test0")
    tryExit([]{
       auto p = ProcessBuilder();
       p.SetProgram("ping 8.8.8.8");				
       std::puts("Stream output of process ping to stdout.");
       p.StreamLines([](std::string line){
            std::cout << " line = " << line << std::endl;
            return true;
         });
       return EXIT_SUCCESS;
       });

if(std::string(argv[1]) == "test1")
    tryExit([]{
        std::puts("Get output of tasklist.");
         auto p = ProcessBuilder("dir .");		
         p.SetCWD("C:\\windows\\system32");
         std::cout << "Process output = " << std::endl;
         auto out = p.GetOutput();
         std::cout << out << std::endl;

         std::ofstream fs("output.log");
         fs << " ==>>> Process output = " << "\n";
         fs << " +=================+ " << "\n";
         fs << out;	
         return EXIT_SUCCESS;
   });

if(std::string(argv[1]) == "test2")
   tryExit([]{
          std::puts("Launch process and wait for its termination");
          auto p = ProcessBuilder("notepad");
          p.Run();
          std::cout << "Waiting for process termination" << std::endl;
          p.Wait();
          std::cout << "Process terminated. OK." << std::endl;
          return EXIT_SUCCESS;
    });	

if(std::string(argv[1]) == "test3")
        tryExit([]{
            std::puts("Launch process and wait for its termination");
            auto p = ProcessBuilder("notepad");
            p.Run();
            std::cout << "Enter RETURN to terminate process => PID = " << p.GetPID() << std::endl;
            std::cin.get();
            p.Terminate();
            std::cout << " Process terminated OK.";
            return EXIT_SUCCESS;
        });

//========= File: ProcessBuilder.hpp - Header ===================//

/** Requires: <iostream> <string>, <functional> <vector> <windows.h> */
class ProcessBuilder
{
private:
    // Program to be run 
    std::string              m_program;
    // Arguments passed to the program 
    std::vector<std::string> m_args = {};
    // If this flag is true, the program is launched on console 
    bool                     m_console = true;
    std::string              m_cwd; 
    STARTUPINFO              m_si = { sizeof(STARTUPINFO)};
    PROCESS_INFORMATION      m_pi;
public:	
    using SELF = ProcessBuilder&;
    using LineConsumer = std::function<bool (std::string)>;

    ProcessBuilder() = default;
    ProcessBuilder(const std::string& program, const std::vector<std::string>& args = {});
    ProcessBuilder(const ProcessBuilder&) = delete;
    auto operator=(const ProcessBuilder&)  = delete;	
    ~ProcessBuilder();
    ProcessBuilder(ProcessBuilder&& rhs);
    auto operator=(ProcessBuilder&& rhs) -> SELF;
    auto SetProgram(const std::string& program) -> SELF;	
    auto SetConsole(bool flag) -> SELF;
    /** Set process directory.
     * @param path - Process directory path.
     */
    auto SetCWD(const std::string& path) -> SELF;	
    /** Start process without waiting for its termination.  */
    auto Run() -> bool;
    auto Wait() -> void;
    // Start process and wait for its termination. 
    auto RunWait() -> bool;
    auto GetPID() -> DWORD;
    auto Terminate() -> bool;
    auto isRunning() -> bool;	
    auto StreamLines(LineConsumer consumer) -> bool; 
    auto GetOutput() -> std::string;	
private:
    auto ReadLineFromHandle(HANDLE hFile) -> std::pair<bool, std::string>;	
}; //========= End of Class ProcessBuilder ===== // 

SOCKET socket(int af, int type, int protocol)

int connect(SOCKET s, LPSOCKADDR lpName, int nNameLen);

struct hostent {
    // Official name of the host (PC).
    char FAR *  h_name;           
    // A NULL -terminated array of alternate names.
    char FAR * FAR *h_aliases;    
    // The type of address being returned; for Windows Sockets this is always PF_INET.
    short       h_addrtype;       
    // The length, in bytes, of each address; for PF_INET, this is always 4.
    short       h_length;         
    // A NULL-terminated list of addresses for the host. Addresses are returned in network byte order.
    char FAR * FAR *h_addr_list;  
};

/*
 * Internet address (old style... should be updated)
 */
struct in_addr {
        union {
                struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
                struct { u_short s_w1,s_w2; } S_un_w;
                u_long S_addr;
        } S_un;

struct sockaddr {
 ushort sa_family;
 char sa_data[14];
};

struct sockaddr_in {
        short   sin_family;
        u_short sin_port;
        struct  in_addr sin_addr;
        char    sin_zero[8];
};

struct sockaddr_in6 {
        short   sin6_family;
        u_short sin6_port;
        u_long  sin6_flowinfo;
        struct  in6_addr sin6_addr;
        u_long  sin6_scope_id;
};

typedef struct sockaddr_in6 SOCKADDR_IN6;
typedef struct sockaddr_in6 *PSOCKADDR_IN6;
typedef struct sockaddr_in6 FAR *LPSOCKADDR_IN6;

typedef struct WSAData {
 WORD wVersion;
 WORD wHighVersion;
 char szDescription[WSADESCRIPTION_LEN+1];
 char szSystemStatus[WSASYS_STATUS_LEN+1];
 unsigned short iMaxSockets;
 unsigned short iMaxUdpDg;
 char FAR* lpVendorInfo;
} WSADATA, *LPWSADATA; 

WSADATA wd;
// Intialize with Winsocks 1.0 
WSAStartup(MAKEWORD(1, 0), &wd);
// Intialize with Winsocks 2.0 
WSAStartup(MAKEWORD(2, 2), &wd);
// Intialize with Winsocks 2.0 
WSAStartup(MAKEWORD(2, 0), &wd);

/* Show IPV4 Address of a given hostname
 *===================================*/

#include <iostream>
#include <string.h>
#include <windows.h>

int main(int argc, char *argv[])
{
  if(argc != 2){
    std::cerr << "Usage: " << argv[0] << " <hostname> " << std::endl;
    return EXIT_FAILURE;
  }
  // Initialize Winsock 2.2 
  WSADATA wsaData;
  WSAStartup(MAKEWORD(2, 2), &wsaData);
 
  hostent* host = gethostbyname(argv[1]);
  char *ip = inet_ntoa(*reinterpret_cast<in_addr*>(*host->h_addr_list));

  std::cout << " ipv4 Address = " << ip                << std::endl;
  std::cout << " hostname     = " << host->h_name      << std::endl;
  std::cout << " Address type = " << host->h_addrtype  << std::endl;
 
  WSACleanup();
  return EXIT_SUCCESS;
}

λ client-socket-shell1.exe
Usage: client-socket-shell1.exe [HOSTNAME or ADDRESS] [PORT]

λ client-socket-shell1.exe 192.168.18.90 9090
 [SERVER SENT] >>

int main(int argc, char** argv){
    if(argc < 3){
            std::cerr << "Usage: " << argv[0] << " [HOSTNAME or ADDRESS] [PORT]" << std::endl;
            return EXIT_FAILURE;
    }

    // Client configuration 
    const char*  host = argv[1];
    unsigned int port = std::stoi(argv[2]);
    ... ... ...    ... ... ...    ... ... ...

//Start up Winsock…
WSADATA wsadata;
int error = WSAStartup(0x0202, &wsadata);
if(error){
        std::cerr << "Error: failed to initialize WinSock." << std::endl;
        return EXIT_FAILURE;
}

// Create client socket 
SOCKET client = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(client == INVALID_SOCKET){
        std::cerr << "Error, I cannot create socket" << std::endl;
        return EXIT_FAILURE;
}
SOCKADDR_IN  addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family      = AF_INET;
addr.sin_addr.s_addr = inet_addr(host);
addr.sin_port        = htons(port);

// Attemp to connect to server and exit on failure. 
int connval = connect(client, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
if(connval == SOCKET_ERROR){
        std::cerr << "Error: cannot connect to server." << std::endl;
        //Returns status code other than zero
        return EXIT_FAILURE;
}

std::string msgClientConnect = " [CLIENT] Connected to server OK.\n";	
::send(client, msgClientConnect.c_str(), msgClientConnect.size(), 0);

std::string msg = " [CLIENT SHELL]>> ";
std::string echo;

bool flag = true;
while(flag){    
   ::send(client, msg.c_str(), msg.size(), 0);
   // Create a buffer with 2024 bytes or 2kb
   std::string buffer(2024, 0);
   //Returns the number of received bytes 
   int n = ::recv(client, &buffer[0], buffer.size()-1, 0);
   echo = " => [ECHO] " + buffer + "\n";
   ::send(client, echo.c_str(), echo.size(), 0);
   if(WSAGetLastError() == SOCKET_ERROR){
       std::cerr << "Disconnected OK." << std::endl;
       flag  = false;
       break;
   } else {
       buffer.resize(n);
       if(buffer == "exit\n" ){
               std::string exitMessage = " [CLIENT] Disconnect gracefully - OK.\n";
               ::send(client, exitMessage.c_str(), exitMessage.size(), 0);				
               std::cerr << "[LOG] I got an exit message. Shutdowing socket now!" << "\n";
               std::cerr << "[LOG] Gracefully disconnecting application" << "\n";
               std::cerr.flush();
               break;
       }        
       std::cout << " [SERVER SENT] >> " << buffer ; //<< std::endl;
       // Force writing buffer to the stdout
       std::cout.flush();
   }
}

std::cerr << "Finished." << std::endl;   
::closesocket(client);
::WSACleanup();    
// Returns status code 0
return EXIT_SUCCESS;

HINTERNET WINAPI InternetOpen(
    LPCTSTR lpszAgent,
    DWORD   dwAccessType,
    LPCTSTR lpszProxyName, 
    LPCTSTR lpszProxyBypass, 
    DWORD   dwFlags
);

HINTERNET InternetConnect(
    HINTERNET       hInternet,
    LPCTSTR         lpszServerName,
    INTERNET_PORT   nServerPort,
    LPCTSTR         lpszUsername,
    LPCTSTR         lpszPassword,
    DWORD           dwService,
    DWORD           dwFlags,
    DWORD_PTR       dwContext
);

BOOL InternetCloseHandle(
    HINTERNET hInternet
);

BOOL InternetReadFile(
    HINTERNET hFile,
    LPVOID    lpBuffer,
    DWORD     dwNumberOfBytesToRead,
    LPDWORD   lpdwNumberOfBytesRead
);

HRESULT downloadFile(std::string url, std::string file){
   HRESULT hr = URLDownloadToFileA(
        // (pCaller)    Pointer to IUknown instance (not needed)
        NULL
        // (szURL)      URL to the file that will be downloaded
        ,url.c_str()
        // (szFileName) File name that the downloaded file will be saved.
        ,file.c_str()
        // (dwReserved) Reserverd - always 0
        ,0
        // (lpfnCB)     Status callback
        ,NULL       
        );
   return hr;
}

void testHTTPRequest(){
     // Reference: http://www.cplusplus.com/forum/beginner/75062/
     HINTERNET hConnect = InternetOpen("Fake browser",INTERNET_OPEN_TYPE_PRECONFIG,NULL, NULL, 0);
     if(!hConnect){
             std::cerr << "Error: Connection Failure.";
             return;
     }
     HINTERNET hAddr = InternetOpenUrl(
          hConnect
          ,"http://www.httpbin.org/get"
          ,NULL
          ,0
          ,INTERNET_FLAG_PRAGMA_NOCACHE | INTERNET_FLAG_KEEP_CONNECTION
          ,0
          );

     if ( !hAddr )
     {
          DWORD errorCode = GetLastError();
          std::cerr << "Failed to open URL" << '\n' << "Error Code = " << errorCode;
          InternetCloseHandle(hConnect);
          return;
     }

     // Buffer size - 4kb or 4096 bytes 
     char  bytesReceived[4096];
     DWORD NumOfBytesReceived = 0;
     while(InternetReadFile(hAddr, bytesReceived, 4096, &NumOfBytesReceived) && NumOfBytesReceived )
     {
             std::cout << bytesReceived;
     }

     InternetCloseHandle(hAddr);
     InternetCloseHandle(hConnect);
   
} // --- EoF testHTTPRequest() --- // 

// ==================  File Download  ========================= //
//
HRESULT hr;

hr = downloadFile("http://httpbin.org/image/jpeg", "image.jpeg");   
if(SUCCEEDED(hr))
        std::cout << "Download successful OK." << '\n';
else
        std::cout << "Download failed." << '\n';

hr = downloadFile("httpxpabin.org/image/jpeg-error", "image2.jpeg");    
if(SUCCEEDED(hr))
    std::cout << "Download sucessful OK." << '\n';
else
    std::cout << "Download failed." << '\n';

//=============== HTTP Protocol ===================================//
//
testHTTPRequest();

if(!launchedFromConsole()){
        std::cout << "Type RETURN to exit" << std::endl;
        std::cin.get();     
}   
return 0;

int WINAPI WinMain(
        // Handle to current application isntance 
        HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        // Command line 
        LPSTR     lpCmdLine,
        int       nCmdShow
        ){
   ... .... ... 
     return 0;
 }

int WINAPI WinMain( ... ){

    OutputDebugString("Starting WinMain Application");
    std::puts("It will not print to Console - Starting WinMain Application");	
    ... ... ... 
    OutputDebugString("Registered Window Class OK.");

    ... ... 
    OutputDebugString(" [INFO] Exiting application. OK.");	
    // Success status code
    return 0;
}

 // ---------- Within WinMain function ----------// 

 //Window class name must be unique 
 const char wincClassName [] = "NameOfWindow";

 // Win32 Window class structure
 WNDCLASSEX wc;
 // Win32 message structure 
 MSG Msg;        	
	
// Name to identify the class with. 
 wc.lpszClassName = wincClassName;
 //Pointer to the window procedure for this window class. 
 wc.lpfnWndProc = windowProcedure;	
 // 1 - Register Windows Size
 wc.cbSize = sizeof(WNDCLASSEX);

 wc.style  = 0;
 //Amount of extra data allocated for this class in memory. Usually 0
 wc.cbClsExtra = 0;
 //Amount of extra data allocated in memory per window of this type. Usually 0. 
 wc.cbWndExtra = 0;
 //Handle to application instance (that we got in the first parameter of WinMain()). 
 wc.hInstance = hInstance;
 // Large (usually 32x32) icon shown when the user presses Alt+Tab. 
 wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
 // Cursor that will be displayed over our window. 
 wc.hCursor = LoadCursor(NULL, IDC_ARROW);
 // Background Brush to set the color of our window. 
 wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); // (HBRUSH) CreateSolidBrush(RGB(10, 20, 30)); // 
 // Background Brush to set the color of our window. 
 wc.lpszMenuName = NULL;	
 // Small (usually 16x16) icon to show in the taskbar and in the top left corner of the window. 
 wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);  
 OutputDebugString("Registered Window Class OK.");

if(!RegisterClassEx(&wc)) {
        MessageBox(NULL,
        "Window Registration Failed!",
        "Error!",
        MB_ICONEXCLAMATION | MB_OK);
        //Error status code 
        return -1;
}
std::cout << "Class Registered" << std::endl;

int width = 500, height = 400;
int pos_left = 400, pos_top = 100;

HWND hwnd = CreateWindowA(
        wc.lpszClassName,
        "Title of Window",
        WS_OVERLAPPEDWINDOW,
        pos_left,
        pos_top,
        width,
        height,
        nullptr,
        nullptr,
        hInstance,
        nullptr
        );	
OutputDebugString(" [INFO] Window created OK");

ShowWindow(hwnd, nCmdShow);
std::cout << "nCmdShow = " << nCmdShow << std::endl;
UpdateWindow(hwnd);

//---- Message Loop ----------//
while(GetMessage(&Msg, NULL, 0, 0) > 0 ){
     TranslateMessage(&Msg);
     DispatchMessage(&Msg);
}

OutputDebugString(" [INFO] Exiting application. OK.");

// Window Procedure - Process window messages or events
LRESULT CALLBACK windowProcedure (
     HWND   hwnd    // Window Handle (Window object)
    ,UINT   msg     // Window Message  
    ,WPARAM wParam  // Additional message information
    ,LPARAM lParam  // Additional message information
    ){
     // Variable initialized one. 
     static auto ignored_messages = std::set<UINT>{
             WM_MOUSEMOVE, WM_NCHITTEST, WM_SETCURSOR, WM_IME_NOTIFY
     };

     // Ignore messages which can flood the logging 
     // if(msg != WM_MOUSEMOVE && msg != WM_NCMOUSEMOVE
     //    && msg != WM_QUIT && msg != WM_NCHITTEST )
     if(ignored_messages.find(msg) == ignored_messages.end())
          OutputDebugString(WinMessageToString(msg).c_str());	
     ... ... ... 	... ... ... 	... ... ... 	... ... ...      

   // Process messages 
   switch(msg)
   {
   case WM_CREATE:
        SetWindowTextA(hwnd, "Change Window Title");		
        OutputDebugString(" [INFO] Window created. OK.");
        break;
   case WM_CLOSE:
        OutputDebugString(" [INFO] Window closed. OK.");
        DestroyWindow(hwnd);
        break;
   }
  ... 
  return 0;
  }

// Process messages 
switch(msg)
{
case WM_CREATE:
      SetWindowTextA(hwnd, "Change Window Title");		
      OutputDebugString(" [INFO] Window created. OK.");
      break;
case WM_CLOSE:
      OutputDebugString(" [INFO] Window closed. OK.");
      DestroyWindow(hwnd);
      break;
case WM_DESTROY:
      OutputDebugString(" [INFO] Exiting application. OK.");
      PostQuitMessage(0);
      break;
case WM_MOVE:
      std::cerr << " [INFO] Move window." << std::endl;
      break; 
case WM_PAINT:
  {
      // GDI - Graphics Devices Interface Here
      //--------------------------------------------
      PAINTSTRUCT ps;
      HDC hdc;
      // std::cerr << " [INFO] Windown painting" << std::endl;
      hdc = BeginPaint(hwnd, &ps);
      std::string text = "Hello world Window!";		
      TextOutA(hdc, 125, 200, text.c_str(), text.size());
      Ellipse(hdc, 100, 100, 160, 160);
      Rectangle(hdc, 100, 100, 160, 160);
      EndPaint(hwnd, &ps);		
  }
  break;
  default:
     return DefWindowProc(hwnd, msg, wParam, lParam);
}

case WM_PAINT:
  {
      // GDI - Graphics Devices Interface Here
      //--------------------------------------------
      PAINTSTRUCT ps;
      HDC hdc;
      // std::cerr << " [INFO] Windown painting" << std::endl;
      hdc = BeginPaint(hwnd, &ps);
      std::string text = "Hello world Window!";		
      TextOutA(hdc, 125, 200, text.c_str(), text.size());
      Ellipse(hdc, 100, 100, 160, 160);
      Rectangle(hdc, 100, 100, 160, 160);
      EndPaint(hwnd, &ps);		
  }

// Window Procedure - Process window messages or events 
LRESULT CALLBACK windowProcedure ( ... ){
    // Variable initialized one. 
    static auto ignored_messages = std::set<UINT>{
       WM_MOUSEMOVE, WM_NCHITTEST, WM_SETCURSOR, WM_IME_NOTIFY
    };

    // Ignore messages which can flood the logging 
    // if(msg != WM_MOUSEMOVE && msg != WM_NCMOUSEMOVE
    //    && msg != WM_QUIT && msg != WM_NCHITTEST )
    if(ignored_messages.find(msg) == ignored_messages.end())
        OutputDebugString(WinMessageToString(msg).c_str());	
... ... ... 

/** Get a human-readable description of a Windows message as a
 * string */
auto WinMessageToString(UINT msg) -> std::string {
     /** Database of Windows messages - full list of messages here: 
      *   https://wiki.winehq.org/List_Of_Windows_Messages
      */
     static auto WindowMessages = std::map<UINT, std::string>{
             {1, "WM_CREATE"}, {2, "WM_DESTROY"}, {5, "WM_SIZE"},
             {6, "WM_ACTIVATE"}, {13, "WM_SIZE"}, {22, "WM_SETVISIBLE"},
             {23, "WM_ENABLE"},  {29, "WM_PAINT"}, {3, "WM_MOVE"}, {30, "WM_CLOSE"},
             {32, "WM_SETCURSOR"},  {72, "WM_FULLSCREEN"}, {85, "WM_COPYDATA"},
             {512, "WM_MOUSEMOVE"},{132, "WM_NCHITTEST"}, {641, "WM_IME_SETCONTEXT"},
             {8, "WM_KILLFOCUS"}, {134, "WM_NCACTIVATE"}, {28, "WM_ACTIVATEAPP"},
             {160, "WM_NCMOUSEMOVE"}, {161, "WM_NCLBUTTONDOWN"},
             {36, "WM_GETMINMAXINFO"}, {642, "WM_IME_NOTIFY"}, {433, "WM_CAPTURECHANGED"},
             {534, "WM_MOVING"}, {674, "WM_NCMOUSELEAVE"}, {675, "WM_MOUSELEAVE"},
             {532, "WM_SIZING"}, {533, "WM_CAPTURECHANGED"}, {127, "WM_GETICON"},
             {20, "WM_ERASEBKGND"}, {70, "WM_WINDOWPOSCHANGING"}, {71, "WM_WINDOWPOSCHANGED"},
             {273, "WM_COMMAND"}, {274, "WM_SYSCOMMAND"}, {275, "WM_TIMER"}, {513, "WM_LBUTTONDOWN"},
             {514, "WM_LBUTTONUP"}
     };
     // Code for debugging messages sent to Window
     static std::stringstream ss;
     ss.str("");
     ss << " [TRACE] WNPROC Message =>  "
        << " Code = " << msg;
     if(WindowMessages.find(msg) != WindowMessages.end())
         ss << " ; Message = " << WindowMessages[msg];
     else
         ss << " ; Message = Unknown "; 
     return ss.str();
}

int WINAPI WinMain(
        // Handle to current application isntance 
        HINSTANCE hInstance,
        HINSTANCE hPrevInstance,
        // Command line 
        LPSTR     lpCmdLine,
        int       nCmdShow
        ){
   ... .... ... 
     return 0;
 }

int main(int argc, char** argv){
    //---- Get WinMain Parameters ----//
    HINSTANCE hInstance = GetModuleHandle(NULL);
    STARTUPINFO si;
    GetStartupInfo(&si);  
    int nCmdShow = si.wShowWindow;
    ... ... ... ... 

   return 0
}

$ cl.exe gui-without-winmain.cpp /EHsc /Zi /nologo /link /subsystem:windows /entry:mainCRTStartup user32.lib gdi32.lib 

HRESULT URLDownloadToFile(
                         LPUNKNOWN            pCaller,
                         LPCTSTR              szURL,
                         LPCTSTR              szFileName,
  _Reserved_             DWORD                dwReserved,
                         LPBINDSTATUSCALLBACK lpfnCB
);

HRESULT URLDownloadToFileW(
                         LPUNKNOWN            pCaller,
                         LPCWSTR              szURL,
                         LPCWSTR              szFileName,
  _Reserved_             DWORD                dwReserved,
                         LPBINDSTATUSCALLBACK lpfnCB
);

$ g++ dynamic-loading1.cpp -o out2.exe -std=c++1z && out2.exe

  [INFO] DLL Loaded OK
 ============ EXPERIMENT 1 ===================
  [INFO] Function loaded OK
  [INFO] Download successful OK. 
 ============ EXPERIMENT 2 ===================
  [INFO] Download successful OK. 
  [INFO] Application ended gracefully. OK.

// Wide-unicode strings 
std::wstring fileURL = L"http://httpbin.org/image/jpeg";
std::wstring file1   = L"download-file1.jpeg";
std::wstring file2   = L"download-file2.jpeg";	

// Wide unicode version for LoadLibrary API
HMODULE hLib = ::LoadLibraryW(L"urlmon.dll");
if(hLib == nullptr){
     std::cerr << " [ERROR] Error: failed to load shared library" << std::endl;
     // Early return on Error. 
     return EXIT_FAILURE;		
}
std::cerr << " [INFO] DLL Loaded OK" << std::endl;

 // C+11 type alias for function pointer 
 using FunptrType =
    HRESULT (__cdecl *)(LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK);
//  __cdecl can be omited 
//  HRESULT (__cdecl *)(LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK);

 // Alternative 2 for type alias (C++98/03)
 typedef HRESULT (__cdecl * FunptrTypeTypedef)(LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK);

FARPROC hFunc = ::GetProcAddress(hLib, "URLDownloadToFileW");
if(hFunc == nullptr){
    std::cerr << " [Error] Failed to load function from DLL" << std::endl;
    return EXIT_FAILURE;
}
std::cerr << " [INFO] Function loaded OK" << std::endl;

// Functin Pointer 
FunptrType URLDownloadToFileFunPTR = reinterpret_cast<FunptrType>(hFunc);	  	

HRESULT result1 = URLDownloadToFileFunPTR(nullptr, fileURL.c_str(), file1.c_str(), 0, nullptr);
if(SUCCEEDED(result1))
    std::cerr << " [INFO] Download successful OK. " << std::endl;
else
    std::cerr << " [ERROR] Download failure. " << std::endl;

std::cout << "============ EXPERIMENT 2 ===================" << std::endl;
// Same cast as reinterpret_cast 
void* hFunc2 = (void*) ::GetProcAddress(hLib, "URLDownloadToFileW");
// Omit error checking if(hFunct2 == nullptr){ ... }

// Note: Calling convention __cdecl can be omitted
using URLDownloadToFileW_t =
    auto __cdecl (LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK) -> HRESULT;
//  auto (LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK) -> HRESULT;

auto DownloadFile = reinterpret_cast<URLDownloadToFileW_t*>(hFunc2);

HRESULT hresult2 = DownloadFile(nullptr, fileURL.c_str(), file2.c_str(), 0, nullptr);
if(SUCCEEDED(result1))
    std::cerr << " [INFO] Download successful OK. " << std::endl;
else
    std::cerr << " [ERROR] Download failure. " << std::endl;

::FreeLibrary(hLib);
std::cerr << " [INFO] Application ended gracefully. OK." << std::endl;

$ dumpbin /exports C:\Windows\System32\urlmon.dll > C:\Users\archbox\Desktop\result.txt

Microsoft (R) COFF/PE Dumper Version 14.12.25835.0
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file C:\Windows\System32\urlmon.dll

File Type: DLL

  Section contains the following exports for urlmon.dll

    00000000 characteristics
    F6A98BC3 time date stamp
        0.00 version
         100 ordinal base
         481 number of functions
         132 number of names

    ordinal hint RVA      name

        121    0 000718E0 AsyncGetClassBits
        122    1 000AE7A0 AsyncInstallDistributionUnit
        123    2 000A0CD0 BindAsyncMoniker
        124    3 000CF110 CAuthenticateHostUI_CreateInstance
        125    4 000AF130 CDLGetLongPathNameA
        126    5 000AF150 CDLGetLongPathNameW
        127    6 00107B70 CORPolicyProvider
        128    7 000AE830 CoGetClassObjectFromURL
        129    8 000AED90 CoInstall
        130    9 00035E90 CoInternetCanonicalizeIUri
        131    A 00035FB0 CoInternetCombineIUri     
    ... ... ...     ... ... ...     ... ... ...     ... ... ... 
        227   71 000E48C0 URLDownloadA
        228   72 000EDF10 URLDownloadToCacheFileA
        229   73 000EE090 URLDownloadToCacheFileW
        230   74 000EE200 URLDownloadToFileA
        231   75 0006D300 URLDownloadToFileW
        232   76 000E4920 URLDownloadW
        233   77 000EE350 URLOpenBlockingStreamA
        234   78 000EE430 URLOpenBlockingStreamW
        235   79 000EE540 URLOpenPullStreamA
        236   7A 000EE610 URLOpenPullStreamW
        237   7B 000EE6E0 URLOpenStreamA
    ... ... ...     ... ... ...     ... ... ...     ... ... ... 
  Summary

        D000 .data
        1000 .didat
        1000 .isoapis
        F000 .pdata
       3D000 .rdata
        3000 .reloc
       52000 .rsrc
      117000 .text

// Wide-unicode strings 
std::wstring fileURL = L"http://httpbin.org/image/jpeg";
std::wstring file1   = L"download-file1.jpeg";
std::wstring file2   = L"download-file2.jpeg";	

auto dll = DLLLoader("urlmon.dll");
if(!dll){
        std::cerr << "[Error] failed to load DLL." << std::endl;
        return EXIT_FAILURE;
}
std::cerr << "[INFO] DLL loaded OK." << std::endl;

std::cout << "===== Experiment 1 =========== " << std::endl;

auto URLDownloadToFileW =
    dll.GetFunction<HRESULT (LPUNKNOWN,
                             LPCWSTR,
                             LPCWSTR,
                             DWORD,
                             LPBINDSTATUSCALLBACK)>("URLDownloadToFileW");

if(URLDownloadToFileW == nullptr){
    std::cerr << "[Error] failed to load function. " << std::endl;
    return EXIT_FAILURE;
}
std::cerr << "[INFO] Function URLDownloadToFileW loaded OK. " << std::endl;

HRESULT result1 = URLDownloadToFileW(nullptr, fileURL.c_str(), file1.c_str(), 0, nullptr);
if(SUCCEEDED(result1))
    std::cerr << " [INFO] Download successful OK. " << std::endl;
else
    std::cerr << " [ERROR] Download failure. " << std::endl; 

std::cout << "===== Experiment 2 =========== " << std::endl;
// Note: Calling convention __cdecl can be omitted
using URLDownloadToFileW_t =
    HRESULT (*) (LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPBINDSTATUSCALLBACK);	

auto URLDownloadToFileW2 =
    dll.GetFunction<URLDownloadToFileW_t>("URLDownloadToFileW");

HRESULT result2 =
    URLDownloadToFileW(nullptr, fileURL.c_str(), file2.c_str(), 0, nullptr);

if(SUCCEEDED(result2))
    std::cerr << " [INFO] Download successful OK. " << std::endl;
else
    std::cerr << " [ERROR] Download failure. " << std::endl;	   	
return 0;

//========== File: DLLLoader.hpp =======//
class DLLLoader
{
private:
     HMODULE      m_hLib;
     std::string  m_file;
public:
   DLLLoader(const std::string& file);
   DLLLoader(const DLLLoader&) = delete;	
   DLLLoader(DLLLoader&& rhs);
   ~DLLLoader();
   auto operator=(const DLLLoader&) = delete;
   auto operator=(DLLLoader&& rhs);

   auto GetFile() const ->  std::string;
   auto IsLoaded() const -> bool;
   operator bool() const;

   template<class FunctionSignature>
   auto GetFunction(const std::string& functionName ) const -> FunctionSignature*
   {
      if(m_hLib == nullptr)
         return nullptr;		
      FARPROC hFunc = ::GetProcAddress(m_hLib, functionName.c_str());
      if(hFunc == nullptr)
         return nullptr;
      return reinterpret_cast<FunctionSignature*>(hFunc);
   }	
};

///==== Implementations - file: DLLoader.hpp =======//

DLLLoader::DLLLoader(const std::string& file):
     m_file(file),
     m_hLib(::LoadLibraryA(file.c_str()))
{
}

// Move CTOR
DLLLoader::DLLLoader(DLLLoader&& rhs):
        m_hLib(std::move(rhs.m_hLib)),
        m_file(std::move(rhs.m_file))
{   	
}
auto DLLLoader::operator=(DLLLoader&& rhs)		
{
    std::swap(this->m_hLib, rhs.m_hLib);
    std::swap(this->m_file, rhs.m_file);
}
	
DLLLoader::~DLLLoader()
{
   std::cerr << " [INFO] DLL handler released OK." << std::endl;
   if(m_hLib != nullptr)
           ::FreeLibrary(m_hLib);
}

auto DLLLoader::GetFile() const ->  std::string
{
   return m_file;
}
	
auto DLLLoader::IsLoaded() const -> bool
{
   return m_hLib == nullptr;
}

DLLLoader::operator bool() const
{
   return m_hLib != nullptr;
}

#define WINAPI __stdcall

#define CALLBACK __stdcall

#define FALSE 0
#define TRUE  1

typedef void*  HANDLE;
typedef void*  HMODULE;
typedef void*  HINSTANCE;
typedef void*  HTASK;
typedef void*  HKEY;
typedef void*  HDESK;
typedef void*  HMF;
typedef void*  HEMF;
typedef void*  HPEN;
typedef void*  HRSRC;
typedef void*  HSTR;
typedef void*  HWINSTA;
typedef void*  HKL;
typedef void*  HGDIOBJ;

typedef HANDLE  HDWP;
typedef HANDLE* LPHANDLE;

typedef void* HWND;
typedef void* HMENU;
typedef void* HACCEL;
typedef void* HBRUSH;
typedef void* HFONT;
typedef void* HDC;
typedef void* HICON;
typedef void* HRGN;
typedef void* HMONITOR;

#define SUCCEEDED(hr)         (((HRESULT)(hr)) >= 0)
#define FAILED(hr)            (((HRESULT)(hr)) < 0)
#define HRESULT_CODE(hr)      ((hr) & 0xFFFF)
#define HRESULT_FACILITY(hr)  (((hr) >> 16) & 0x1fff)
#define HRESULT_SEVERITY(hr)  (((hr) >> 31) & 0x1)

// Create an HRESULT value from component pieces
#define MAKE_HRESULT(sev,fac,code) \
    ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )

#define _HRESULT_TYPEDEF_(_sc) _sc
#define _HRESULT_TYPEDEF_(_sc) ((HRESULT)_sc)
#define E_UNEXPECTED                     _HRESULT_TYPEDEF_(0x8000FFFFL)
#define E_NOTIMPL                        _HRESULT_TYPEDEF_(0x80004001L)
#define E_OUTOFMEMORY                    _HRESULT_TYPEDEF_(0x8007000EL)
#define E_INVALIDARG                     _HRESULT_TYPEDEF_(0x80070057L)
#define E_NOINTERFACE                    _HRESULT_TYPEDEF_(0x80004002L)
#define E_POINTER                        _HRESULT_TYPEDEF_(0x80004003L)
#define E_HANDLE                         _HRESULT_TYPEDEF_(0x80070006L)
#define E_ABORT                          _HRESULT_TYPEDEF_(0x80004004L)
#define E_FAIL                           _HRESULT_TYPEDEF_(0x80004005L)
#define E_ACCESSDENIED                   _HRESULT_TYPEDEF_(0x80070005L)
#define E_NOTIMPL                        _HRESULT_TYPEDEF_(0x80000001L)
#define E_OUTOFMEMORY                    _HRESULT_TYPEDEF_(0x80000002L)
#define E_INVALIDARG                     _HRESULT_TYPEDEF_(0x80000003L)
#define E_NOINTERFACE                    _HRESULT_TYPEDEF_(0x80000004L)
#define E_POINTER                        _HRESULT_TYPEDEF_(0x80000005L)
#define E_HANDLE                         _HRESULT_TYPEDEF_(0x80000006L)
#define E_ABORT                          _HRESULT_TYPEDEF_(0x80000007L)
#define E_FAIL                           _HRESULT_TYPEDEF_(0x80000008L)
#define E_ACCESSDENIED                   _HRESULT_TYPEDEF_(0x80000009L)
#define E_PENDING                        _HRESULT_TYPEDEF_(0x8000000AL)
#define E_BOUNDS                         _HRESULT_TYPEDEF_(0x8000000BL)
#define E_CHANGED_STATE                  _HRESULT_TYPEDEF_(0x8000000CL)
#define E_ILLEGAL_STATE_CHANGE           _HRESULT_TYPEDEF_(0x8000000DL)
#define E_ILLEGAL_METHOD_CALL            _HRESULT_TYPEDEF_(0x8000000EL)

 ... ... 
#define WM_NULL         0x0000
#define WM_CREATE       0x0001
#define WM_DESTROY      0x0002
#define WM_MOVE         0x0003
#define WM_SIZE         0x0005
#define WM_ACTIVATE     0x0006

#define WM_SETFOCUS                     0x0007
#define WM_KILLFOCUS                    0x0008
#define WM_ENABLE                       0x000A
#define WM_SETREDRAW                    0x000B
#define WM_SETTEXT                      0x000C
#define WM_GETTEXT                      0x000D
#define WM_GETTEXTLENGTH                0x000E
#define WM_PAINT                        0x000F
#define WM_CLOSE                        0x0010
#define WM_DEVMODECHANGE                0x001B
#define WM_ACTIVATEAPP                  0x001C
#define WM_FONTCHANGE                   0x001D
#define WM_TIMECHANGE                   0x001E
#define WM_CANCELMODE                   0x001F
#define WM_SETCURSOR                    0x0020
#define WM_MOUSEACTIVATE                0x0021
#define WM_CHILDACTIVATE                0x0022
#define WM_QUEUESYNC                    0x0023
#define WM_GETMINMAXINFO                0x002
#define WM_COPYDATA                     0x004A
#define WM_CANCELJOURNAL                0x004B
  ... ... ... 

HANDLE CreateFile(
    LPCTSTR lpFileName,	// pointer to name of the file 
    DWORD dwDesiredAccess,	// access (read-write) mode 
    DWORD dwShareMode,	// share mode 
    LPSECURITY_ATTRIBUTES lpSecurityAttributes,	// pointer to security descriptor 
    DWORD dwCreationDistribution,	// how to create 
    DWORD dwFlagsAndAttributes,	// file attributes 
    HANDLE hTemplateFile 	// handle to file with attributes to copy  
   );	

BOOL ReadFile(
    HANDLE hFile,	// handle of file to read 
    LPVOID lpBuffer,	// address of buffer that receives data  
    DWORD nNumberOfBytesToRead,	// number of bytes to read 
    LPDWORD lpNumberOfBytesRead,	// address of number of bytes read 
    LPOVERLAPPED lpOverlapped 	// address of structure for data 
   );	

BOOL WriteFile(
    HANDLE hFile,	// handle to file to write to 
    LPCVOID lpBuffer,	// pointer to data to write to file 
    DWORD nNumberOfBytesToWrite,	// number of bytes to write 
    LPDWORD lpNumberOfBytesWritten,	// pointer to number of bytes written 
    LPOVERLAPPED lpOverlapped 	// pointer to structure needed for overlapped I/O
   );

BOOL CopyFile(
  LPCTSTR lpExistingFileName, // name of an existing file
  LPCTSTR lpNewFileName,      // name of new file
  BOOL bFailIfExists          // operation if file exists
);

BOOL DeleteFile(
  LPCTSTR lpFileName   // file name
);

BOOL MoveFile(
  LPCTSTR lpExistingFileName, // file name
  LPCTSTR lpNewFileName       // new file name
);

BOOL CreateDirectory(
  LPCTSTR lpPathName,                         // directory name
  LPSECURITY_ATTRIBUTES lpSecurityAttributes  // SD
);

BOOL RemoveDirectory(
  LPCTSTR lpPathName   // directory name
);

// ANSI 
int system(const char* command);
// Wide-unicode version 
int _wsystem(const wchar_t* command);

FILE *_popen(
    const char *command,
    const char *mode
);
FILE *_wpopen(
    const wchar_t *command,
    const wchar_t *mode
);

BOOL CreateProcessA(
  LPCSTR                lpApplicationName,   // const char*
  LPSTR                 lpCommandLine,       // char*
  LPSECURITY_ATTRIBUTES lpProcessAttributes, // SECURITY_ATTRIBUTES*
  LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SECURITY_ATTRIBUTES*
  BOOL                  bInheritHandles,     // 
  DWORD                 dwCreationFlags,     // DWORD - int 
  LPVOID                lpEnvironment,       // void*
  LPCSTR                lpCurrentDirectory,  // const char*
  LPSTARTUPINFOA        lpStartupInfo,       // STARTUPINFOA*
  LPPROCESS_INFORMATION lpProcessInformation // PROCESS_INFORMATION*
);

BOOL CreateProcessW(
  LPCWSTR               lpApplicationName,   // const wchar_t*
  LPWSTR                lpCommandLine,       // wchar_t*
  LPSECURITY_ATTRIBUTES lpProcessAttributes, // SECURITY_ATTRIBUTES*
  LPSECURITY_ATTRIBUTES lpThreadAttributes,  // SECURITY_ATTRIBUTES*
  BOOL                  bInheritHandles,     // C++ bool 
  DWORD                 dwCreationFlags,     // DWORD / int 
  LPVOID                lpEnvironment,       // void* 
  LPCWSTR               lpCurrentDirectory,  // const wchar_t*
  LPSTARTUPINFOW        lpStartupInfo,       // STARTUPINFOW*
  LPPROCESS_INFORMATION lpProcessInformation // PPROCESS_INFORMATION*
);

DWORD GetCurrentProcessId();

HANDLE GetCurrentProcess();

BOOL TerminateProcess(
  HANDLE hProcess,
  UINT   uExitCode
);

HANDLE OpenProcess(
  DWORD dwDesiredAccess,
  BOOL  bInheritHandle,
  DWORD dwProcessId
);

BOOL WINAPI ReadProcessMemory(
  _In_  HANDLE  hProcess,
  _In_  LPCVOID lpBaseAddress,
  _Out_ LPVOID  lpBuffer,
  _In_  SIZE_T  nSize,
  _Out_ SIZE_T  *lpNumberOfBytesRead
);

HANDLE CreateRemoteThread(
  HANDLE                 hProcess,
  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
  SIZE_T                 dwStackSize,
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID                 lpParameter,
  DWORD                  dwCreationFlags,
  LPDWORD                lpThreadId
);

// ANSI API 
HMODULE LoadLibraryA( LPCSTR lpLibFileName);
// Unicode API 
HMODULE LoadLibraryW(LPCWSTR lpLibFileName);

FARPROC GetProcAddress(HMODULE hModule, LPCSTR  lpProcName);

BOOL FreeLibrary(HMODULE hLibModule);