如何对std::u8string进行Unicode字符级逐字符迭代？

要实现std::u8string的Unicode字符（码点）级迭代，无需转换到UTF-16/UTF-32，核心思路是直接解析UTF-8的多字节序列，从字节流中提取对应的Unicode码点。以下是两种高效实现方式：

一、手动解析的基础实现 #

通过自定义函数逐字节解析UTF-8序列，每次读取一个完整的Unicode码点，同时移动迭代器位置。这种方式开销极小，仅涉及位运算和迭代器操作。

#include <iostream>
#include <string>
#include <cstdint>
#include <stdexcept>
#include <iterator>

// 从当前迭代器位置读取一个UTF-8码点，迭代器会移动到下一个码点的起始
char32_t read_utf8_code_point(std::u8string::const_iterator& it, const std::u8string::const_iterator& end) {
    if (it == end) {
        throw std::out_of_range("已到达字符串末尾");
    }

    uint8_t first_byte = static_cast<uint8_t>(*it);
    // 单字节字符（ASCII）
    if ((first_byte & 0x80) == 0) {
        return static_cast<char32_t>(*it++);
    }
    // 2字节UTF-8序列
    else if ((first_byte & 0xE0) == 0xC0) {
        if (std::next(it) == end) {
            throw std::invalid_argument("不完整的UTF-8多字节序列");
        }
        char32_t code_point = (first_byte & 0x1F) << 6;
        code_point |= static_cast<uint8_t>(*++it) & 0x3F;
        ++it;
        return code_point;
    }
    // 3字节UTF-8序列
    else if ((first_byte & 0xF0) == 0xE0) {
        if (std::next(it, 2) >= end) {
            throw std::invalid_argument("不完整的UTF-8多字节序列");
        }
        char32_t code_point = (first_byte & 0x0F) << 12;
        code_point |= (static_cast<uint8_t>(*++it) & 0x3F) << 6;
        code_point |= static_cast<uint8_t>(*++it) & 0x3F;
        ++it;
        return code_point;
    }
    // 4字节UTF-8序列
    else if ((first_byte & 0xF8) == 0xF0) {
        if (std::next(it, 3) >= end) {
            throw std::invalid_argument("不完整的UTF-8多字节序列");
        }
        char32_t code_point = (first_byte & 0x07) << 18;
        code_point |= (static_cast<uint8_t>(*++it) & 0x3F) << 12;
        code_point |= (static_cast<uint8_t>(*++it) & 0x3F) << 6;
        code_point |= static_cast<uint8_t>(*++it) & 0x3F;
        ++it;
        return code_point;
    }
    else {
        throw std::invalid_argument("无效的UTF-8起始字节");
    }
}

int main() {
    std::u8string utf8 = u8"α.β";
    auto it = utf8.begin();
    
    try {
        while (it != utf8.end()) {
            char32_t cp = read_utf8_code_point(it, utf8.end());
            // 转换为int类型使用
            int code_point_int = static_cast<int>(cp);
            std::cout << "Unicode码点: U+" << std::hex << code_point_int 
                      << " (对应字符: " << static_cast<char32_t>(cp) << ")\n";
        }
    } catch (const std::exception& e) {
        std::cerr << "解析错误: " << e.what() << "\n";
    }

    return 0;
}

运行后会输出3个结果，对应α、.、β三个Unicode字符。

二、基于C++20范围的视图适配器 #

如果希望用更符合现代C++风格的范围for循环迭代，可以自定义一个视图适配器，封装解析逻辑，让迭代更简洁：

#include <iostream>
#include <string>
#include <cstdint>
#include <stdexcept>
#include <iterator>
#include <ranges>

struct UTF8CodePointView : std::ranges::view_base {
    std::u8string::const_iterator begin_;
    std::u8string::const_iterator end_;

    // 自定义迭代器
    struct Iterator {
        using iterator_category = std::input_iterator_tag;
        using value_type = char32_t;
        using difference_type = std::ptrdiff_t;

        std::u8string::const_iterator it_;
        std::u8string::const_iterator end_;
        value_type current_cp_;

        Iterator(std::u8string::const_iterator it, std::u8string::const_iterator end) 
            : it_(it), end_(end) {
            if (it != end) {
                current_cp_ = read_code_point();
            }
        }

        char32_t read_code_point() {
            uint8_t first_byte = static_cast<uint8_t>(*it_);
            if ((first_byte & 0x80) == 0) {
                return static_cast<char32_t>(*it_++);
            } else if ((first_byte & 0xE0) == 0xC0) {
                char32_t cp = (first_byte & 0x1F) << 6;
                cp |= static_cast<uint8_t>(*++it_) & 0x3F;
                ++it_;
                return cp;
            } else if ((first_byte & 0xF0) == 0xE0) {
                char32_t cp = (first_byte & 0x0F) << 12;
                cp |= (static_cast<uint8_t>(*++it_) & 0x3F) << 6;
                cp |= static_cast<uint8_t>(*++it_) & 0x3F;
                ++it_;
                return cp;
            } else if ((first_byte & 0xF8) == 0xF0) {
                char32_t cp = (first_byte & 0x07) << 18;
                cp |= (static_cast<uint8_t>(*++it_) & 0x3F) << 12;
                cp |= (static_cast<uint8_t>(*++it_) & 0x3F) << 6;
                cp |= static_cast<uint8_t>(*++it_) & 0x3F;
                ++it_;
                return cp;
            }
            throw std::invalid_argument("无效的UTF-8序列");
        }

        value_type operator*() const { return current_cp_; }
        Iterator& operator++() {
            if (it_ != end_) {
                current_cp_ = read_code_point();
            }
            return *this;
        }
        Iterator operator++(int) {
            auto temp = *this;
            ++*this;
            return temp;
        }
        bool operator==(const Iterator& other) const { return it_ == other.it_; }
        bool operator!=(const Iterator& other) const { return !(*this == other); }
    };

    Iterator begin() const { return Iterator(begin_, end_); }
    Iterator end() const { return Iterator(end_, end_); }
};

// 构造函数辅助函数
UTF8CodePointView as_utf8_code_points(const std::u8string& s) {
    return {s.begin(), s.end()};
}

int main() {
    std::u8string utf8 = u8"α.β";
    // 直接用范围for循环迭代Unicode码点
    for (char32_t cp : as_utf8_code_points(utf8)) {
        int code_point_int = static_cast<int>(cp);
        std::cout << "Unicode码点: U+" << std::hex << code_point_int << "\n";
    }
    return 0;
}

关键注意事项 #

• 上述代码假设输入的UTF-8序列是合法的，若需要处理非法序列（如截断的多字节序列），可以在解析逻辑中添加跳过无效字节或自定义错误处理的逻辑。
• char32_t是C++标准中用于表示Unicode码点的类型，转换为int即可满足你的需求（常用Unicode码点均在int的取值范围内）。
• 两种实现都无需编码转换，完全在原std::u8string的字节流上操作，性能开销极低。

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