Windows API Documentation

Core Concepts

Understanding the fundamental building blocks of Windows APIs is crucial. This includes:

• Processes and Threads
• Memory Management
• Inter-Process Communication (IPC)
• Windows Messaging System

Processes and Threads

Manage the execution context of your applications. Learn how to create, terminate, and synchronize processes and threads.

Key APIs:

• CreateProcess(): Creates a new process and its primary thread.
• ExitProcess(): Terminates the calling process.
• CreateThread(): Creates a new thread within the calling process.
• ExitThread(): Terminates the calling thread.
• WaitForSingleObject(): Waits for a specified object to be signaled.

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

int main() {
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    ZeroMemory(&si, sizeof(si));
    si.cb = sizeof(si);
    ZeroMemory(&pi, sizeof(pi));

    // Start the child process.
    if (!CreateProcess(
        NULL,           // No module name (use command line)
        "notepad.exe",  // Command line
        NULL,           // Process handle not inheritable
        NULL,           // Thread handle not inheritable
        FALSE,          // Set handle inheritance to FALSE
        0,              // No creation flags
        NULL,           // Use parent's environment block
        NULL,           // Use parent's starting directory
        &si,            // Pointer to STARTUPINFO structure
        &pi)            // Pointer to PROCESS_INFORMATION structure
    ) {
        std::cerr << "CreateProcess failed (" << GetLastError() << ")." << std::endl;
        return 1;
    }

    // Wait until child process exits.
    WaitForSingleObject(pi.hProcess, INFINITE);

    // Close process and thread handles.
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);

    std::cout << "Notepad process has finished." << std::endl;
    return 0;
}
                

Memory Management

Efficiently allocate and manage memory for your applications to ensure stability and performance.

Key APIs:

• HeapAlloc() / HeapFree(): Allocate and free memory from a heap.
• VirtualAlloc() / VirtualFree(): Allocate, commit, or decommit regions of memory.
• GlobalAlloc() / GlobalFree(): Allocate global memory objects (older API, often used for compatibility).
• LocalAlloc() / LocalFree(): Allocate local memory objects (older API).

Inter-Process Communication (IPC)

Enable different processes to exchange data and synchronize their operations.

Key APIs:

• Pipes (CreatePipe())
• Memory-Mapped Files (CreateFileMapping(), MapViewOfFile())
• Windows Messages (SendMessage(), PostMessage())
• Sockets (Winsock API)
• Remote Procedure Calls (RPC)

Windows Messaging System

The heart of Windows UI programming. Learn how windows, controls, and applications communicate through messages.

Key Concepts:

• Message Loops
• Window Procedures (WndProc)
• Message Queues
• Standard Messages (e.g., WM_PAINT, WM_COMMAND, WM_CREATE)

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
    switch (uMsg) {
        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);
            // Paint application content here
            FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
            EndPaint(hwnd, &ps);
            return 0;
        }
        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
        default:
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
    }
}
                

Further Exploration

Dive deeper into specific areas of the Windows API:

• Kernel APIs: System-level operations, I/O, and device management.
• User Interface: Creating windows, controls, and managing user input.
• Networking: TCP/IP, Winsock, and network services.
• Security: Access control, authentication, and encryption.
• Graphics: GDI, DirectX, and visual rendering.