基于VS2017、C++与WindowsAPI开发语言学习应用并实现UTF-32文件读写

Hey Willi, great call opting for UTF-32 in your language learning app—supporting niche European languages while getting hands-on with Unicode’s fixed-width encoding is a win-win. Since you’re working with VS2017, C++, and the Win32 API on the latest Windows 10 Preview (no backward compatibility hoops to jump through), here’s a practical, native approach to UTF-32 file read/write operations tailored to your stack:

Windows uses little-endian byte order natively, so we’ll target UTF-32LE (with an optional BOM for compatibility with other tools). Here’s how to read a UTF-32 file into a buffer of 32-bit characters:

#include <windows.h>
#include <vector>

typedef UINT32 UTF32CHAR; // Explicit 32-bit Unicode character type

bool ReadUTF32File(const wchar_t* filePath, std::vector<UTF32CHAR>& outBuffer, bool skipBOM = true)
{
    // Open the file in binary mode to preserve raw byte data
    HANDLE hFile = CreateFileW(
        filePath,
        GENERIC_READ,
        FILE_SHARE_READ,
        nullptr,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        nullptr
    );

    if (hFile == INVALID_HANDLE_VALUE)
        return false;

    // Get file size to allocate buffer
    LARGE_INTEGER fileSize;
    if (!GetFileSizeEx(hFile, &fileSize))
    {
        CloseHandle(hFile);
        return false;
    }

    if (fileSize.QuadPart == 0)
    {
        CloseHandle(hFile);
        return true; // Empty file, nothing to read
    }

    // Allocate buffer for UTF-32 characters (each is 4 bytes)
    size_t charCount = fileSize.QuadPart / sizeof(UTF32CHAR);
    outBuffer.resize(charCount);

    // Read entire file into buffer
    DWORD bytesRead;
    if (!ReadFile(
        hFile,
        outBuffer.data(),
        static_cast<DWORD>(fileSize.QuadPart),
        &bytesRead,
        nullptr
    ) || bytesRead != static_cast<DWORD>(fileSize.QuadPart))
    {
        CloseHandle(hFile);
        outBuffer.clear();
        return false;
    }

    // Skip BOM if requested (UTF-32LE BOM is 0xFFFE0000)
    if (skipBOM && charCount > 0 && outBuffer[0] == 0xFFFE0000)
    {
        outBuffer.erase(outBuffer.begin());
    }

    CloseHandle(hFile);
    return true;
}

When writing, you can choose to include the UTF-32LE BOM to make the file’s encoding explicit for other applications. Here’s a function to write your UTF-32 buffer to disk:

bool WriteUTF32File(const wchar_t* filePath, const std::vector<UTF32CHAR>& inBuffer, bool includeBOM = true)
{
    // Create or overwrite the file in binary mode
    HANDLE hFile = CreateFileW(
        filePath,
        GENERIC_WRITE,
        0,
        nullptr,
        CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL,
        nullptr
    );

    if (hFile == INVALID_HANDLE_VALUE)
        return false;

    DWORD bytesWritten;
    const UTF32CHAR UTF32LE_BOM = 0xFFFE0000;

    // Write BOM first if enabled
    if (includeBOM)
    {
        if (!WriteFile(
            hFile,
            &UTF32LE_BOM,
            sizeof(UTF32CHAR),
            &bytesWritten,
            nullptr
        ) || bytesWritten != sizeof(UTF32CHAR))
        {
            CloseHandle(hFile);
            return false;
        }
    }

    // Write the main character buffer
    if (!inBuffer.empty())
    {
        if (!WriteFile(
            hFile,
            inBuffer.data(),
            static_cast<DWORD>(inBuffer.size() * sizeof(UTF32CHAR)),
            &bytesWritten,
            nullptr
        ) || bytesWritten != static_cast<DWORD>(inBuffer.size() * sizeof(UTF32CHAR)))
        {
            CloseHandle(hFile);
            return false;
        }
    }

    CloseHandle(hFile);
    return true;
}

• Byte Order: Windows is little-endian, so UTF-32LE is the natural choice. The BOM helps other tools (like text editors) recognize the encoding correctly.
• Error Handling: The examples include basic error checking, but you can expand on this with GetLastError() to debug specific issues (e.g., file access permissions).
• Win32 UI Integration: If you need to display UTF-32 text in Win32 controls, convert it to UTF-16 (Windows’ native WCHAR type) using MultiByteToWideChar with CP_UTF32. For code points above U+FFFF, this function will handle surrogate pairs automatically.
• VS2017 Compatibility: All functions and types used here are fully supported in VS2017’s C++ compiler—no extra setup or library dependencies needed.

This approach keeps you firmly within the Win32 ecosystem, avoids external libraries, and aligns with your goal of practicing UTF-32 handling. Feel free to tweak it to fit specific parts of your language learning app!

内容的提问来源于stack exchange，提问作者Willi