如何限制UTF-8字符串操作（如substr）避免多字节字符拆分？

这种包装类的思路完全成立，核心就是通过封装隐藏底层std::string的字节级操作权限，从根源上避免开发者误调用substr、operator[]这类可能截断多字节字符的方法，同时只暴露安全的UTF-8相关操作。

实现思路与示例 #

你可以设计一个包装类，仅对外提供只读的完整字符串访问和基于UTF-8字符的安全操作，禁止直接操作底层字节：

#include <string>
#include <stdexcept>

// UTF-8字符串包装类，屏蔽不安全的字节级操作
class Utf8String {
public:
    // 构造时接收const std::string&，确保底层字符串不可被外部修改
    explicit Utf8String(const std::string& str) : str_(str) {
        // 可选：提前校验UTF-8合法性，拦截非法输入
        if (!is_valid_utf8(str)) {
            throw std::invalid_argument("Invalid UTF-8 string");
        }
    }

    // 只读获取完整字符串，不暴露可修改接口
    const std::string& get() const noexcept {
        return str_;
    }

    // 安全的子串操作：按UTF-8字符数截取，而非字节
    Utf8String substr(size_t char_pos, size_t char_count = std::string::npos) const {
        size_t byte_start = 0;
        size_t current_char = 0;

        // 定位起始字符对应的字节位置
        while (current_char < char_pos && byte_start < str_.size()) {
            unsigned char c = static_cast<unsigned char>(str_[byte_start]);
            size_t char_len = utf8_char_length(c);
            if (byte_start + char_len > str_.size()) {
                throw std::out_of_range("Character position out of bounds");
            }
            byte_start += char_len;
            current_char++;
        }

        if (current_char < char_pos) {
            throw std::out_of_range("Character position exceeds string length");
        }

        size_t byte_end = byte_start;
        current_char = 0;

        // 定位结束字符对应的字节位置
        while (current_char < char_count && byte_end < str_.size()) {
            unsigned char c = static_cast<unsigned char>(str_[byte_end]);
            size_t char_len = utf8_char_length(c);
            if (byte_end + char_len > str_.size()) {
                throw std::out_of_range("Character count exceeds remaining length");
            }
            byte_end += char_len;
            current_char++;
        }

        return Utf8String(str_.substr(byte_start, byte_end - byte_start));
    }

    // 获取UTF-8字符数量（而非字节数）
    size_t character_count() const noexcept {
        size_t count = 0;
        size_t i = 0;
        while (i < str_.size()) {
            unsigned char c = static_cast<unsigned char>(str_[i]);
            i += utf8_char_length(c);
            count++;
        }
        return count;
    }

private:
    const std::string str_; // 底层存储，类内部也不可修改

    // 辅助函数：计算单个UTF-8字符的字节长度
    static size_t utf8_char_length(unsigned char c) noexcept {
        if ((c & 0x80) == 0) return 1;       // ASCII字符
        else if ((c & 0xE0) == 0xC0) return 2;
        else if ((c & 0xF0) == 0xE0) return 3;
        else if ((c & 0xF8) == 0xF0) return 4;
        return 1; // 非法字符，简化处理
    }

    // 辅助函数：校验UTF-8字符串合法性
    static bool is_valid_utf8(const std::string& str) noexcept {
        size_t i = 0;
        while (i < str.size()) {
            unsigned char c = static_cast<unsigned char>(str[i]);
            size_t len = utf8_char_length(c);
            if (i + len > str.size()) return false;
            // 检查后续字节是否符合10xxxxxx格式
            for (size_t j = 1; j < len; j++) {
                unsigned char next_c = static_cast<unsigned char>(str[i + j]);
                if ((next_c & 0xC0) != 0x80) return false;
            }
            i += len;
        }
        return true;
    }
};

关键优势 #

1. 强制安全操作：底层std::string被封装为私有成员，外部无法直接调用substr、operator[]等字节级方法，彻底避免截断多字节字符的风险。
2. 可扩展安全接口：后续可以根据需求添加拼接、查找等操作，所有操作都基于UTF-8字符逻辑实现，而非字节。
3. 轻量可控：相比引入第三方UTF-8库，自定义包装类更灵活，能贴合你的业务场景做针对性设计。

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