undefined | Better HN

0 pointsmaccard1mo ago0 comments

Serialization is the canonical example. Being able to turn

    struct MyStruct {
      int val = 42;
      string name = "my name";
    };

into

    {
      "val": 42, // if JSON had integers, and comments of course
      "name": "my name",
    }

is incredibly powerfuly. If reflection supported attributes (i can't believe it shipped without, honestly), then you could also mark members as [[ignore]] and skip them.

0 comments

8 comments · 2 top-level

bluGill1mo ago· 4 in thread

It is powerful, but I'm not sure it is a good idea. Other languages have it, and there is lots of experience in all the ways things go wrong in the real world. I'm inclined to say you should hand write this code because eventually you will discover something weird anyway.

electroly1mo ago

Can you give an example of a language ecosystem that went with reflection-based JSON serialization/deserialization and then went on to regret it? I can't think of any, and don't agree with your conclusion. It works great, and manually writing serialization and matching deserialization code is terrible, annoying, error-prone work.

maccardOP1mo ago

I disagree. Rust's defacto default is serde, golang comes with batteries included, dotnet/java have had it for _years_, and all the dynamic languages do it.

SuperV12341mo ago

I think this is a very bad take -- once you write it by hand you have to manually keep it in sync with the actual struct and ensure you made no mistakes. Reflection guarantees 1-1 future-proof mapping with the actual C++ struct, avoids boilerplate, and ensures that the serialization logic is correct.

bluGill1mo ago

The protocol is important though, not the internal structure. When you only have exactly one version of a program talking to the same version of itself you don't care. However when you are mixing versions or worse programming language (and thus can't mix structs which are implementation details of your language) the protocol is what matters.

That is if you are worried about doing this by hand reflection is not the answer, something like protobuf where your data structures are generated is the answer.

1 more reply

SuperV12341mo ago· 2 in thread

You can achieve that since C++20 (or C++17 if you don't care about the member names). E.g. https://www.linkedin.com/posts/vittorioromeo_cpp-gamedev-ref...

(The link above shows ImGui generation, but the same exact logic can be applied for serialiation to JSON/YAML/whatever.)

maccardOP1mo ago

Sure, but

> The magic sauce? Boost.PFR! An incredibly clever library that enables reflections on aggregates, even in C++17.

That's not vanilla C++!

SuperV12341mo ago

...so what? It's just a header you have to #include.

1 more reply

j / k navigate · click thread line to collapse

0 comments

8 comments · 2 top-level

bluGill1mo ago· 4 in thread

electroly1mo ago

maccardOP1mo ago

I disagree. Rust's defacto default is serde, golang comes with batteries included, dotnet/java have had it for _years_, and all the dynamic languages do it.

SuperV12341mo ago

bluGill1mo ago

That is if you are worried about doing this by hand reflection is not the answer, something like protobuf where your data structures are generated is the answer.

1 more reply

SuperV12341mo ago· 2 in thread

You can achieve that since C++20 (or C++17 if you don't care about the member names). E.g. https://www.linkedin.com/posts/vittorioromeo_cpp-gamedev-ref...

(The link above shows ImGui generation, but the same exact logic can be applied for serialiation to JSON/YAML/whatever.)

maccardOP1mo ago

Sure, but

> The magic sauce? Boost.PFR! An incredibly clever library that enables reflections on aggregates, even in C++17.

That's not vanilla C++!

SuperV12341mo ago

...so what? It's just a header you have to #include.

1 more reply

j / k navigate · click thread line to collapse