C++20中同一对象编译时赋值部分成员、运行时赋值部分成员的实现是否合理？

当前实现的核心问题 #

你代码里用const_cast修改constexpr对象的成员属于未定义行为。constexpr声明的对象默认是const类型，const对象的非mutable成员是只读的，强行通过const_cast去掉const属性修改，编译器可能因优化忽略你的修改，或导致不可预期的运行结果，这是C++标准明确禁止的操作。

正确的实现方式 #

1. 用mutable标记可运行时修改的成员 #

把Property的value成员声明为mutable，这样即使是const对象也能修改该成员，无需const_cast：

constexpr std::string_view one = "prop1";
constexpr std::string_view two= "prop2";

struct Property
{
    std::string_view title;
    mutable int value; // 标记为mutable，允许const对象修改

    // 优化constexpr构造函数，直接初始化成员
    constexpr Property(std::string_view t = "", int v = 0) : title{t}, value{v}{}
};

struct Foo
{
    int v1{};
    int v2{};

    Property prop1;
    Property prop2;

    // 构造函数中直接初始化Property的title，避免构造函数体内赋值
    constexpr Foo(int x = 0 ,  int y = 0) 
        : v1{x}, v2{y},
          prop1{one},
          prop2{two}
    {}
    
    // 直接调用即可，无需const_cast
    void setValue_Prop1(int a) const
    {
        prop1.value = a;
    }

    void setValue_Prop2(int a) const
    {
        prop2.value = a;
    }
};

int main()
{
     constexpr Foo foo{ 1,2 };

     static_assert(foo.prop1.title == "prop1");
     static_assert(foo.prop2.title == "prop2");
    
     foo.setValue_Prop1(10); // 直接调用const成员函数修改mutable成员
     foo.setValue_Prop2(20);
     
     std::cout << foo.prop1.title << " " << foo.prop1.value << std::endl;
     std::cout << foo.prop2.title << " " << foo.prop2.value << std::endl;
}

2. 大量属性的简化方案 #

当属性数量超过10个时，手动编写每个Property成员和setValue函数会非常繁琐，可通过宏定义减少重复代码：

// 定义宏，自动生成Property成员和对应的setValue函数
#define DEFINE_PROPERTY(prop_name, prop_title) \
    Property prop_name{prop_title}; \
    void setValue_##prop_name(int a) const { prop_name.value = a; }

struct Foo
{
    int v1{};
    int v2{};

    // 批量定义属性
    DEFINE_PROPERTY(prop1, "prop1")
    DEFINE_PROPERTY(prop2, "prop2")
    DEFINE_PROPERTY(prop3, "prop3")
    // ... 其他10+个属性依次添加

    constexpr Foo(int x = 0 ,  int y = 0) : v1{x}, v2{y} {}
};

这种方式既保证了编译时初始化title，又能在运行时安全修改value，同时大幅减少重复代码的编写。

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