如何处理数据成员指针与mutable字段的const上下文修改问题？

我实现了一个自定义容器类，它接收元素类型的数据成员指针来更新状态。由于关联字段不属于元素的核心状态范畴，需要在不修改元素其他部分的const上下文中更新，因此将这类字段声明为mutable，允许在const上下文中修改。

示例代码：

struct ContainerStatus {};

struct ContainerItem
{
    mutable ContainerStatus status;
};

template <typename T>
class Container
{
public:
    Container(ContainerStatus T::*statusField)
        : m_statusField(statusField) { }

    void push_back(T* ptr)
    {
        // 分配内存并移动指针...
        // 更新指向元素的状态
        // T可能是const，比如Container<const ...>
    }
    
private:
    ContainerStatus T::*m_statusField;
};

ContainerItem item;
Container<ContainerItem> container;
container.push_back(&item);

但更新状态时，数据成员指针无法识别字段的mutable属性，认为只能在非const元素上修改，因此不得不使用const_cast转换元素或状态才能在const上下文中更新：

ptr->*status = ...; // 如果T是const会报错

const_cast<std::remove_const_t<T>*>(ptr)->*status = ...;
// 或者
const_cast<ContainerStatus&>(ptr->*status) = ...;

这种方式不够优雅，且除非能保证字段是mutable的，否则会破坏const正确性，目前缺乏编译期保障。因此想知道：是否有办法标注数据成员指针，使其明确指向mutable字段？

1. 用模板元编程做编译期验证 #

通过类型萃取判断传入的数据成员指针是否指向mutable字段，在编译阶段就拦截不符合要求的参数，同时安全访问mutable成员：

先实现判断成员是否为mutable的类型萃取：

#include <type_traits>

template <typename MemPtr>
struct is_mutable_member;

template <typename T, typename U>
struct is_mutable_member<U T::*> : std::false_type {};

template <typename T, typename U>
struct is_mutable_member<U mutable T::*> : std::true_type {};

template <typename MemPtr>
constexpr bool is_mutable_member_v = is_mutable_member<MemPtr>::value;

修改容器类，添加编译期检查并安全访问：

template <typename T>
class Container
{
public:
    template <typename MemPtr>
    Container(MemPtr statusField)
        : m_statusField(statusField) 
    {
        static_assert(is_mutable_member_v<MemPtr>, "状态字段必须是mutable类型");
        static_assert(std::is_same_v<std::remove_cv_t<decltype(std::declval<T>().*statusField)>, ContainerStatus>, 
                      "状态字段类型必须为ContainerStatus");
    }

    void push_back(T* ptr)
    {
        // 因成员是mutable，用std::remove_const_t安全获取非const指针
        auto non_const_ptr = const_cast<std::remove_const_t<T>*>(ptr);
        non_const_ptr->*m_statusField = ContainerStatus{};
    }
    
private:
    std::remove_const_t<ContainerStatus> std::remove_const_t<T>::*m_statusField;
};

当传入非mutable成员时，编译器会直接报错，提供编译期保障。

2. 自定义包装类标记mutable成员指针 #

创建专门的包装类，从类型层面区分普通成员指针和mutable成员指针：

template <typename T, typename U>
struct MutableMemberPtr
{
    using Type = U mutable T::*;
    Type ptr;

    explicit MutableMemberPtr(Type p) : ptr(p) {}
};

// 辅助函数简化包装对象创建
template <typename T, typename U>
constexpr auto make_mutable_ptr(U mutable T::*ptr)
{
    return MutableMemberPtr<T, U>(ptr);
}

修改容器类，仅接受该包装类型：

template <typename T>
class Container
{
public:
    Container(MutableMemberPtr<std::remove_const_t<T>, ContainerStatus> statusField)
        : m_statusField(statusField.ptr) { }

    void push_back(T* ptr)
    {
        const_cast<std::remove_const_t<T>*>(ptr)->*m_statusField = ContainerStatus{};
    }
    
private:
    ContainerStatus mutable std::remove_const_t<T>::*m_statusField;
};

使用时通过make_mutable_ptr传入成员指针：

ContainerItem item;
Container<ContainerItem> container(make_mutable_ptr(&ContainerItem::status));
container.push_back(&item);

// 传入非mutable成员会直接编译报错：
// struct BadItem { ContainerStatus status; };
// Container<BadItem> bad_container(make_mutable_ptr(&BadItem::status)); // 编译错误

3. 调整容器模板参数，直接约束mutable成员指针类型 #

让容器模板参数包含成员指针类型，从类型系统层面直接约束为mutable成员指针：

template <typename MutableMemPtr>
class Container
{
public:
    using T = std::remove_const_t<std::remove_pointer_t<std::decay_t<decltype(std::declval<MutableMemPtr>().*nullptr)>>>;
    using StatusType = std::remove_const_t<std::decay_t<decltype(std::declval<T>().*std::declval<MutableMemPtr>())>>;

    static_assert(is_mutable_member_v<MutableMemPtr>, "成员指针必须指向mutable字段");
    static_assert(std::is_same_v<StatusType, ContainerStatus>, "状态类型不匹配");

    Container(MutableMemPtr statusField) : m_statusField(statusField) {}

    void push_back(const T* ptr)
    {
        const_cast<T*>(ptr)->*m_statusField = ContainerStatus{};
    }

    void push_back(T* ptr)
    {
        ptr->*m_statusField = ContainerStatus{};
    }
    
private:
    MutableMemPtr m_statusField;
};

使用方式：

ContainerItem item;
Container<ContainerStatus mutable ContainerItem::*> container(&ContainerItem::status);
container.push_back(&item);

// 传入const元素也能正常工作：
const ContainerItem const_item;
Container<ContainerStatus mutable ContainerItem::*> const_container(&ContainerItem::status);
const_container.push_back(&const_item);

• 以上方案均通过编译期检查确保传入的成员是mutable，避免了const_cast的不安全使用
• 方案1和3利用类型萃取直接验证属性，方案2通过包装类做类型区分，都能实现编译期保障
• 选择方案可根据代码架构决定：追求容器模板简洁选方案1或2；希望完全由类型系统约束选方案3

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