Windows API Cheat Sheet: Key Win32 Functions, Commands, and Use Cases

Windows API (Win32) is the foundation on which all Windows applications are built. If you write code that interacts with the system at a low level, you need quick access to key functions: file operations, processes, memory, and the registry. This article is not a general overview, but a compact reference with concrete signatures, examples, and typical usage scenarios. There is no superfluous theory here — only what you will use in day-to-day development.

Basic concepts you need to know before starting

Before diving into the functions, let's go over four important mechanisms without which you cannot properly work with Win32.

Handles (HANDLE) and closing them

Most Win32 functions that open resources (files, processes, registry keys) return a value of type HANDLE — this is an integer handle (an opaque identifier) that the kernel uses to reference an object. It is not a pointer to memory and should not be interpreted as an address. The handle must be closed with CloseHandle (or a specialised function such as RegCloseKey), otherwise a resource leak will occur. Each open handle consumes memory and can lead to system instability over time.

INVALID_HANDLE_VALUE

On error, the CreateFile function returns not NULL but a special value INVALID_HANDLE_VALUE (defined as (HANDLE)-1). It is important to remember: check specifically for this value, not for NULL.

Error codes and GetLastError

Each Win32 function returns its own special error value: it may be FALSE (0) for functions with BOOL return type, NULL for functions returning pointers (e.g., VirtualAlloc, OpenProcess), INVALID_HANDLE_VALUE for CreateFile, or a code other than ERROR_SUCCESS for registry functions. To get the detailed reason, immediately after a failed call use GetLastError(). The error code can be matched with constants from winerror.h (e.g., ERROR_FILE_NOT_FOUND).

Function versions: A and W

Many string functions exist in two variants: with the suffix A (ANSI, single-byte encoding) and W (wide characters, UTF-16). In modern projects, it is recommended to use the W versions, because Windows works internally with UTF-16. Using the A versions involves conversion to the system code page (e.g., Windows-1251), which can distort non-Latin characters. Make sure that the UNICODE and _UNICODE macros are defined in your project so that the wide versions are called by default.

Cloud Servers from €4 / moIntel Xeon Gold 6254 3.1 GHz CPU, SLA 99,9%, 100 Mbps channeltry

Key Win32 functions: summary table

The following tables list the most commonly used functions, grouped by category. For each, we give the purpose, main parameters, return value, and a typical usage scenario.

File and directory operations

Process management

Memory management

Registry operations

Synchronisation primitives

Code examples

Reading a file with error handling

#include <windows.h>
#include <stdio.h>

int main() {
    HANDLE hFile = CreateFileW(
        L"example.txt",
        GENERIC_READ,
        FILE_SHARE_READ,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL
    );

    if (hFile == INVALID_HANDLE_VALUE) {
        DWORD err = GetLastError();
        printf("Failed to open file, error: %lu\n", err);
        return 1;
    }

    char buffer[1024];
    DWORD bytesRead;
    if (!ReadFile(hFile, buffer, sizeof(buffer) - 1, &bytesRead, NULL)) {
        DWORD err = GetLastError();
        printf("Read error: %lu\n", err);
        CloseHandle(hFile);
        return 1;
    }

    buffer[bytesRead] = '\0';
    printf("Content: %s\n", buffer);

    CloseHandle(hFile);
    return 0;
}

Launching a process (Calculator) and waiting for it to finish

STARTUPINFOW si = { sizeof(si) };
PROCESS_INFORMATION pi;
if (CreateProcessW(
        L"C:\\Windows\\System32\\calc.exe",
        NULL, NULL, NULL, FALSE,
        0, NULL, NULL, &si, &pi)) {
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
} else {
    printf("Launch error: %lu\n", GetLastError());
}

Reading a value from the registry

HKEY hKey;
LONG result = RegOpenKeyExW(
    HKEY_LOCAL_MACHINE,
    L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
    0, KEY_READ, &hKey);

if (result == ERROR_SUCCESS) {
    WCHAR buffer[256];
    // Note: the buffer size is passed in bytes, not characters.
    // For a WCHAR array, sizeof(buffer) gives the total size in bytes,
    // which is correct for RegQueryValueExW.
    DWORD bufferSize = sizeof(buffer);
    DWORD type;
    if (RegQueryValueExW(hKey, L"ProductName", NULL, &type,
                         (LPBYTE)buffer, &bufferSize) == ERROR_SUCCESS) {
        wprintf(L"Product name: %s\n", buffer);
    }
    RegCloseKey(hKey);
} else {
    printf("Failed to open key, code: %ld\n", result);
}

Common mistakes and how to avoid them (brief)

• Forgetting to close a handle — always pair opening with CloseHandle or RegCloseKey.
• Checking for NULL instead of INVALID_HANDLE_VALUE — for CreateFile, always check for INVALID_HANDLE_VALUE.
• Ignoring error codes — call GetLastError() immediately after a failed call.
• Mixing ANSI and Unicode — use W versions and define UNICODE.
• Incorrect buffer size — always pass the actual size and check how many bytes were written.

Frequently Asked Questions (FAQ)

Conclusion

This reference covers the main Win32 functions you will need in most application tasks. By mastering file reading, process launching, registry operations, and basic synchronisation, you will be able to create robust system utilities and fine‑tune application behaviour. For deeper study, refer to the official Microsoft Learn documentation, where you will find complete parameter lists and additional examples.

If you are testing Win32 applications that require an isolated environment, consider using a dedicated server — for example, VPS from Serverspace. You can deploy a clean Windows instance there, run experiments with handles and memory, without risking the stability of your main workstation.