Let’s say I have a

struct Params {
   int member1;
   std::string member2;
   int member3 = 42;
   std::shared_ptr<std::string> member4;  
};

Is there a way to wrap each type with std::optional, so I get

struct MaybeParams {
   std::optional<int> member1;
   std::optional<std::string> member2;
   std::optional<int> member3;
   std::optional<std::shared_ptr<std::string>> member4;
};

In real life, the class Params has about 50 data members and is a private struct inside another class; and I can’t modify their definition. I would also prefer a pure C++20 solution, except for the boost library.

I need this to make a universal function used to override some members of the Params, similar in spirit to what can be achieved in Python’s named keyword parameters, with each parameter defaulted to “None”.

Anyway, I believe we can’t solve the problem, because my guts tell me that would require a C++ reflection. But I post the question here nevertheless, in hope that once again the SO community solve an “impossible” problem.

Further context:

I need the MaybeParams class for designated initializer list to have modifiedCopy function like this:

MyClass {
public:
  MyClass(const Params& pars): _pars(pars) {...}
...
private:
  Params _pars;
};

const MyClass modifiedCopy(const MyClass& reference, const MyClass::MaybeParams& what_to_modify);

int main() {
   const auto m1 = MyClass{.member1 = 1, .member2="ABC"};
   const MyClass m2 = modifiedCopy(m1, {
      .member2 = "XYZ",   
      .member4 = make_shared("XXX")
   });
}

I agree that in the ideal world it is better to have classes with fewer data members or have budget to refactor. If anyone knows how to get to that world – please let me know 😉