C++ 如何实现与被引用对象const性绑定的关联式uint8_t数组包装类

之前方案完全失效的本质是：const BufferWrapper的const限定仅作用于指针本身的可改性，而非指向内容的可改性。

• 类内部存储的是uint8_t* m_pau8，当对象为const时，该成员的实际类型是uint8_t* const（指针本身不能改，指向的内存仍可随意修改）
• 拷贝构造const返回值时，编译器仅读取const对象中存储的指针值，写入新的非const对象的同类型成员，const限制在值拷贝过程中完全丢失
• 全程没有任何机制把“被引用内容是const”的信息绑定到包装类的类型系统上，自然无法阻止隐式转换。

采用基于类模板的类型绑定方案，完全兼容C++98及以上标准，无多继承、无复杂SFINAE，对老旧嵌入式编译器友好：

1. 将包装类改造为可参数化指针指向类型的通用模板，让“可写”/“只读”语义直接成为类类型的一部分，而非依赖对象本身的const属性
2. 内部存储的指针类型与模板参数强绑定，从根源上杜绝const属性丢失
3. 利用C++类型转换规则，实现可写缓冲区到只读缓冲区的隐式转换，但反向转换完全阻断

#include <cinttypes>
#include <cstddef>
#include <cstdio>
#include <cstring>

// 通用缓冲区包装模板，T为被指向的元素类型
template <typename T>
class basic_buffer_wrapper
{
public:
    // 构造函数：接受对应类型的指针和长度
    basic_buffer_wrapper(T* data, size_t size) : m_data{data}, m_size{size} {}

    // 隐式转换构造：仅当OtherT*可隐式转为T*时生效
    // 比如 uint8_t* 可转 const uint8_t*，但反过来不行
    template <typename OtherT>
    basic_buffer_wrapper(const basic_buffer_wrapper<OtherT>& other) : 
        m_data{other.m_data}, m_size{other.m_size} {}

    // 修改接口：仅当T为非const类型时可用，const类型下该接口会因类型不匹配编译失败
    void fill(uint8_t value) 
    { 
        memset(m_data, value, m_size); 
    }

    // 下标访问：非const版本返回可写引用（T为const时自动变为返回const引用，无法赋值）
    T& operator[](size_t idx) { return m_data[idx]; }
    // 下标访问：const版本返回只读引用
    const T& operator[](size_t idx) const { return m_data[idx]; }

    size_t length() const { return m_size; }

    // 相等比较：const成员函数，支持不同类型缓冲区的比较
    template <typename OtherT>
    bool operator==(const basic_buffer_wrapper<OtherT>& other) const
    {
        return (m_size == other.m_size) 
            && (0 == memcmp(m_data, other.m_data, m_size));
    }

private:
    // 允许不同模板实例访问私有成员，支持转换构造
    template <typename OtherT> friend class basic_buffer_wrapper;
    T* m_data;
    size_t m_size;
};

// 类型别名：可写缓冲区
using BufferWrapper = basic_buffer_wrapper<uint8_t>;
// 类型别名：只读const缓冲区
using ConstBufferWrapper = basic_buffer_wrapper<const uint8_t>;

// 接受只读缓冲区的消费者函数，可自动接受可写BufferWrapper的隐式转换
void readDataFromBuffer(const ConstBufferWrapper& rcco)
{
    for(size_t ui=0; ui<rcco.length(); ++ui)
    {
        printf("%02x", rcco[ui]);
    }
    printf("\n");
}

// 可变数组包装：返回可写BufferWrapper
template<typename T, size_t N>
BufferWrapper wrapArray(T (&t)[N])
{
    printf("BufferWrapper, ptr=%p, size=%zu\n", t, N);
    return BufferWrapper(t, N);
}

// const数组包装：返回只读ConstBufferWrapper
template<typename T, size_t N>
ConstBufferWrapper wrapArray(const T (&t)[N])
{
    printf("ConstBufferWrapper, ptr=%p, size=%zu\n", t, N);
    return ConstBufferWrapper(t, N);
}

int main()
{
    uint8_t au8[]            = { 0xde, 0xad, 0xbe, 0xef };
    constexpr uint8_t cau8[] = { 0xba, 0xaa, 0xad, 0xc0, 0xde };
    
    readDataFromBuffer(wrapArray(au8));
    readDataFromBuffer(wrapArray(cau8));

    // 以下代码将直接编译报错，从根源阻断UB：
    // 1. wrapArray(cau8)返回的是ConstBufferWrapper类型
    // 2. 不存在从ConstBufferWrapper到BufferWrapper的隐式转换
    // 3. 即使强行构造，ConstBufferWrapper也没有fill、可写下标修改接口
    // BufferWrapper coFoo = wrapArray(cau8); 
    // coFoo[0] = 0xde;
    // coFoo.fill(0xff);

    return 0;
}

• 完全删除了原有实现中的const_cast，所有const属性都在编译期被类型系统绑定，不存在运行时丢失的可能
• 之前能绕过编译检查的错误代码BufferWrapper newObject = wrapArray(my_const_uint8_array);会因为类型不兼容直接报编译错误
• ConstBufferWrapper实例本身没有任何可暴露的修改接口：内部存的是const uint8_t*，下标操作返回const引用，fill函数会因为memset无法写入const内存直接编译失败
• 支持常规的隐式转换：可写的BufferWrapper可以自动传入任何接受ConstBufferWrapper的函数，不需要额外重载
• 实现无多继承、无复杂元编程逻辑，C++98标准下即可编译，适配老旧嵌入式编译器

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