JSON to C++ Struct Generator

What is JSON to C++ Struct Generator?

Modern C++ has no reflection, so the compiler cannot serialize an arbitrary struct to JSON on its own. The de facto solution is nlohmann/json, a header-only library that bridges JSON and your own types through a pair of free functions, to_json and from_json, found via argument-dependent lookup (ADL). This generator produces both the struct and that bridge: it infers a C++ type for each JSON value, converts keys to snake_case, emits nested structs children-first, and — when you enable it — adds the NLOHMANN_DEFINE_TYPE_INTRUSIVE macro so a single line wires up bidirectional conversion. The macro is the load-bearing piece. NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, field1, field2, ...) expands, inside the struct, into the to_json/from_json members the library calls. Because it is intrusive it can access private members; the non-intrusive variant exists for types you cannot modify. Once defined, j.get<MyStruct>() and json(myStruct) just work, including for nested structs and std::vector, because the library recursively dispatches to each member's own conversion. The other C++-specific decision is how to model nullable JSON fields. Since C++17, std::optional<T> is the idiomatic choice — it is a value type, needs no heap allocation, and nlohmann/json serializes a nullopt as JSON null. For C++11/14 the generator falls back to std::unique_ptr<T>, which models the same may-be-absent semantics but owns a heap allocation and is move-only.

How to Use

1. Set the root struct name and an optional namespace to keep generated types out of the global scope
2. Pick your C++ standard — choose C++17 or later to get std::optional for nullable fields; C++11/14 falls back to std::unique_ptr
3. Enable nlohmann/json macros to emit NLOHMANN_DEFINE_TYPE_INTRUSIVE so each struct gets automatic to_json/from_json
4. Enable include guards if you are pasting the output straight into a .hpp header used across translation units
5. Paste your JSON, click Generate, then add nlohmann/json to your build (single header, or find_package(nlohmann_json) with CMake)

Tips & Best Practices

• NLOHMANN_DEFINE_TYPE_INTRUSIVE requires the struct to be default-constructible — from_json default-constructs then assigns. If you add a custom constructor, also declare a default one or the macro will not compile.
• Prefer std::optional<T> over T* or std::unique_ptr<T> for nullable fields in C++17+: optional is a value type with no heap allocation, and nlohmann/json maps std::nullopt to JSON null automatically. Use unique_ptr only for genuinely recursive or polymorphic shapes.
• The INTRUSIVE macro silently errors if the JSON is missing a key that maps to a non-optional field — it throws nlohmann::json::out_of_range. Use NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT to tolerate missing keys, or make those fields std::optional.
• For a field that can be int or string (a sloppy API), use nlohmann::json itself as the field type and inspect .is_string() at runtime — the macro will round-trip it untouched.
• to_json/from_json are found by ADL, so they must live in the same namespace as the struct. If you move the struct into a namespace, the macro handles this automatically; hand-written conversions must follow the same rule or you get an opaque template error.

Frequently Asked Questions

Real-world Examples

{
  "id": 42,
  "name": "Ada Lovelace",
  "active": true,
  "address": null,
  "roles": ["admin", "editor"]
}

#include <nlohmann/json.hpp>
#include <string>
#include <vector>
#include <optional>

struct Address {
    std::string street;
    std::string city;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Address, street, city)
};

struct User {
    int id;
    std::string name;
    bool active;
    std::optional<Address> address;   // JSON null -> std::nullopt
    std::vector<std::string> roles;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(User, id, name, active, address, roles)
};

// Usage:
//   nlohmann::json j = nlohmann::json::parse(text);
//   User u = j.get<User>();
//   nlohmann::json back = u;

{
  "playlistName": "Focus",
  "tracks": [
    { "title": "Reverie", "durationSec": 214.5 },
    { "title": "Glass", "durationSec": 198.0 }
  ]
}

#include <nlohmann/json.hpp>
#include <string>
#include <vector>

struct Track {
    std::string title;
    double duration_sec;
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Track, title, duration_sec)
};

struct Playlist {
    std::string playlist_name;
    std::vector<Track> tracks;   // each element converted via Track's macro
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Playlist, playlist_name, tracks)
};

Related Tools