如何处理可接收const/非const资源指针的C++ View类？

你的核心问题是非const的View<T>能从const byte*构造，进而可能通过非constoperator[]修改原本不可变的内存，触发未定义行为。不想拆分View和ConstView的前提下，有几种比bool readonly成员更优的处理方式：

1. 编译期拦截非法构造（推荐） #

直接限制非constView只能从非constbyte*构造，仅允许const View<T>接收const byte*，编译期就能阻止错误，无需运行时检查：

using std::byte;

template <class T>
class View {
public:
    using value_type = T __attribute__((may_alias));
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using reference = value_type&;
    using const_reference = const value_type&;

    // 非const View仅接受非const byte指针
    View(byte* p) : data(p) {}

    // const View可接受const byte指针
    View(const byte* p) : data(const_cast<byte*>(p)) {}

    // 支持非const View隐式转为const View
    operator View<const T>() const {
        return View<const T>(data);
    }

    // 非const operator[]仅对非const View开放
    reference operator[](int index) {
        return reinterpret_cast<pointer>(data)[index];
    }

    // const operator[]在两种View中都可用
    const_reference operator[](int index) const {
        return reinterpret_cast<const_pointer>(data)[index];
    }

private:
    byte* data;
};

使用示例：

const byte buf[16]{};
View<int> v(buf); // 编译错误：非const View无法从const byte*构造
const View<int> cv(buf); // 合法
cv[0]; // 仅支持读取操作

2. 模板参数标记可变性（单类双模式） #

如果需要同一个类模板同时支持可变/不可变模式，可添加模板参数IsConst，将可变性逻辑放到编译期处理，无运行时开销：

#include <type_traits>
using std::byte;

template <class T, bool IsConst = false>
class View {
public:
    using byte_ptr = std::conditional_t<IsConst, const byte*, byte*>;
    using value_type = T __attribute__((may_alias));
    using pointer = std::conditional_t<IsConst, const value_type*, value_type*>;
    using reference = std::conditional_t<IsConst, const value_type&, value_type&>;

    explicit View(byte_ptr p) : data(p) {}

    // 支持可变View转为不可变View
    operator View<T, true>() const {
        return View<T, true>(data);
    }

    reference operator[](int index) {
        static_assert(!IsConst, "无法修改const View");
        return reinterpret_cast<pointer>(data)[index];
    }

    const value_type& operator[](int index) const {
        return reinterpret_cast<const value_type*>(data)[index];
    }

private:
    byte_ptr data;
};

// 别名简化const View的使用
template <class T>
using ConstView = View<T, true>;

这种方式通过static_assert在编译期给出清晰错误提示，同时避免了运行时检查的性能损耗。

3. 优化运行时检查方案（仅当必须时使用） #

如果坚持要用运行时检查，建议将readonly设为const成员，配合断言或异常抛出，调试期强检查，发布期可选保留：

#include <cassert>
#include <stdexcept>
using std::byte;

template <class T>
class View {
public:
    using value_type = T __attribute__((may_alias));
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using reference = value_type&;
    using const_reference = const value_type&;

    View(byte* p) : data(p), readonly(false) {}
    View(const byte* p) : data(const_cast<byte*>(p)), readonly(true) {}

    reference operator[](int index) {
        assert(!readonly && "尝试修改只读View");
        if (readonly) {
            throw std::runtime_error("无法修改只读View");
        }
        return reinterpret_cast<pointer>(data)[index];
    }

    const_reference operator[](int index) const {
        return reinterpret_cast<const_pointer>(data)[index];
    }

private:
    byte* data;
    const bool readonly; // 设为const避免被意外修改
};

但这种方式存在运行时开销，且只能在运行时发现错误，优先级低于前两种方案。

总结 #

优先选择方案1：通过编译期限制构造逻辑，既简洁又安全，无额外性能损耗；如果需要更灵活的可变性控制，再考虑方案2的模板参数方式。

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