JSON vers C++

Recommandations connexes

About JSON to C++: Turning JSON data into compilable C++ structs

Cas d'utilisation

• REST API integration: Convert JSON responses from backends to C++ structs for strongly-typed HTTP request deserialization with nlohmann::json / cpr
• Microservice interface definition: Convert gRPC / HTTP service request body example JSON to C++ types, unifying server-side model definitions
• Embedded & IoT: Convert device-reported JSON sensor data to C++ structs, parse MQTT / HTTP messages with ArduinoJson or ESP-IDF JSON Parser
• Game development: Convert level configuration and character attribute JSON to C++ structs, making it easy for engines like Unreal Engine or Cocos2d-x to read .json data files
• Financial high-frequency trading: Convert exchange JSON interface responses (OKX / Binance / Xueqiu market data) to C++ structs, parse at nanosecond speed with rapidjson
• C++ Qt client: Convert server JSON configuration to C++ structs, load GUI data with QJsonObject / QJsonDocument
• Boost.JSON / Boost.Beast: Convert HTTP service JSON responses to C++ structs, deserialize with Boost.JSON to write web backends
• Embedded RTOS: Convert FreeRTOS / Zephyr system configuration JSON to C++ structs, read firmware parameters with cJSON
• Algorithms / quantitative: Convert backtesting system JSON configurations to C++ structs, facilitating A/B experiment configuration management and version traceability
• Database migration: Convert JSON documents exported from MongoDB / PostgreSQL to C++ models as reference for cpp-httplib / libpqxx entity fields
• Audio/video / multimedia: Convert FFmpeg / GStreamer configuration JSON to C++ structs for convenient media pipeline parameter reading
• Simulation & modeling: Convert simulation system JSON input configurations to C++ structs, unifying input data formats across sub-models
• Test data construction: Convert real JSON fixtures from backend responses to C++ types for structured assertions in Google Test / Catch2 unit tests
• Structured log parsing: Convert JSON logs captured by ELK / Loki to C++ types for easier filtering and alert rules
• Configuration center migration: Convert Apollo / Nacos / Consul JSON configurations to C++ types for server-side configuration hot reload
• Cross-language collaboration: Backend C++ integrating with frontend TypeScript / Java, same JSON converted to C++ struct and TS interface / Java POJO respectively to keep both sides consistent
• Teaching & training: Convert sample JSON to struct in C++ courses to demonstrate nlohmann::json deserialization and template metaprogramming concepts
• Field naming conversion: After converting snake_case JSON API responses to C++ structs, manually add NLOHMANN_DEFINE_TYPE_INTRUSIVE for field mapping

Comment utiliser

1. Paste JSON content (JSON object recommended) in the left editor, or click the upload button to select a .json / .txt file
2. The tool uses quicktype-core via Web Worker to automatically convert within 400ms; the right side displays C++ header code with std::string / std::vector<T> / nested classes
3. If JSON format errors show a red prompt, click the 'Fix JSON' button to auto-repair common issues like trailing commas and single quotes, then retry
4. Check that the generated struct / class names and field types match expectations; adjust source JSON key names if needed and reconvert
5. Click 'Copy' to paste code into an .h / .hpp file in your IDE and deserialize real API responses with nlohmann/json or rapidjson; or click 'Download' to save as model.h / model.hpp

Fonctionnalités

• Local browser conversion: JSON parsing and C++ code generation are all done in-browser via Web Worker + quicktype-core, raw data never uploaded to any server
• nlohmann::json style output: Automatically generates STL type structs such as std::string / std::vector<T> / double / int64_t / bool, following nlohmann::json deserialization conventions, can be directly parsed by including <nlohmann/json.hpp>
• rapidjson compatible: Generated pure C++ structs don't depend on any third-party library; work with rapidjson Document / GenericValue for high-performance parsing scenarios
• Automatic type inference: JSON strings map to std::string, integers to int64_t / long long, floats to double, booleans to bool, arrays to std::vector<T>, nested objects to independent class / struct
• Automatic nested object splitting: Nested JSON automatically generates independent class / struct (PascalCase naming), avoiding duplicate definitions of the same type
• Automatic std::vector and std::optional handling: JSON arrays become std::vector<T>, potentially null fields become std::optional<T>, following modern C++17 / C++20 practices
• 400ms debounced auto-conversion: Auto-triggers conversion after pasting JSON, real-time C++ header preview on the right, reducing waiting and extra clicks
• One-click JSON error repair: Automatically fixes common format errors like trailing commas, single quotes, missing quotes, continuing code generation after successful repair
• Code highlighting + one-click copy: Right-side CodeMirror renders C++ syntax highlighting; copy the entire header file with one click, or download as .h / .hpp file directly into your project
• localStorage input history + responsive split panes: Automatically saves recent input, quickly recovers after refresh or accidental page close; paste JSON on the left, view C++ code on the right, supports drag-adjustable panel widths, adapts to large screens and mobile
• Zero-dependency header-only output: Generated .h / .hpp are header-only, can be single-file included into any standard C++ project, no additional build configuration needed to work with nlohmann::json / rapidjson / Boost.JSON
• Built-in snake_case to camelCase: Can automatically convert snake_case fields in JSON to C++ recommended camelCase field names, with NLOHMANN_DEFINE_TYPE_INTRUSIVE maintaining snake_case serialization mapping

Exemples de code

// model.hpp (generated by this tool)
// #pragma once
// #include <cstdint>
// #include <optional>
// #include <string>
// #include <vector>
// struct Address {
//   std::string city;
//   std::string zip;
// };
// struct User {
//   int64_t id;
//   std::string name;
//   std::optional<Address> address;
//   std::vector<std::string> tags;
// };

#include <nlohmann/json.hpp>
#include "model.hpp"

using nlohmann::json;

int main() {
    std::string raw = R"({
        "id": 1,
        "name": "Alice",
        "address": { "city": "Beijing", "zip": "100000" },
        "tags": ["cpp", "nlohmann"]
    })";

    // 1) Parse JSON string
    json j = json::parse(raw);

    // 2) Strongly-typed deserialization to struct generated by this tool
    User u = j.get<User>();

    // 3) Access fields
    std::cout << u.name << " lives in "
              << (u.address ? u.address->city : "unknown")
              << std::endl;

    for (const auto& tag : u.tags) {
        std::cout << "tag: " << tag << std::endl;
    }
    return 0;
}

/*
 * Compilation (CMake project):
 *   find_package(nlohmann_json REQUIRED)
 *   target_link_libraries(my_app PRIVATE nlohmann_json::nlohmann_json)
 * Compilation (vcpkg):
 *   vcpkg install nlohmann-json
 * Single-file integration:
 *   Download json.hpp directly from https://github.com/nlohmann/json/releases
 */

#include "rapidjson/document.h"
#include "rapidjson/stringbuffer.h"
#include <iostream>
#include "model.hpp"

int main() {
    const char* raw = R"({
        "id": 1,
        "name": "Alice",
        "address": { "city": "Beijing", "zip": "100000" },
        "tags": ["cpp", "rapidjson"]
    })";

    // 1) rapidjson DOM parsing
    rapidjson::Document doc;
    doc.Parse(raw);

    // 2) Construct struct generated by this tool and fill manually
    User u;
    u.id = doc["id"].GetInt64();
    u.name = doc["name"].GetString();

    if (doc.HasMember("address") && doc["address"].IsObject()) {
        Address addr;
        addr.city = doc["address"]["city"].GetString();
        addr.zip  = doc["address"]["zip"].GetString();
        u.address = addr;
    }

    for (auto& tag : doc["tags"].GetArray()) {
        u.tags.push_back(tag.GetString());
    }

    // 3) Use the filled struct
    std::cout << u.name << ", tags=" << u.tags.size() << std::endl;
    return 0;
}

/*
 * rapidjson high-performance tips:
 *   ① Use rapidjson::MemoryPoolAllocator with StringBuffer for further speedup;
 *   ② For high-frequency scenarios, use SAX-style Reader / Writer for direct streaming;
 *   ③ Enable RAPIDJSON_SSE42 / RAPIDJSON_SIMD macros to use CPU SIMD instructions for acceleration.
 */

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

// Assume this tool generates fields as snake_case: user_name, created_at
// Add the macro below when renaming to camelCase in real projects
struct UserProfile {
    int64_t id;
    std::string userName;       // In JSON it's "user_name"
    std::string emailAddress;   // In JSON it's "email_address"
    std::string createdAt;      // In JSON it's "created_at"
};

// Use NLOHMANN_DEFINE_TYPE_INTRUSIVE to declare mappings inside the class
// Note: must be placed in public section
// 
// NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// Or use non-intrusive macro (avoids modifying the class itself):
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// Usage:
int main() {
    nlohmann::json j = {
        {"id", 1},
        {"user_name", "Alice"},
        {"email_address", "alice@example.com"},
        {"created_at", "2026-07-14T10:00:00.000Z"}
    };

    UserProfile p = j.get<UserProfile>();
    // Serialization also outputs original field names
    std::cout << j.dump(2) << std::endl;
    return 0;
}

/*
 * Tips:
 *   ① Intrusive macro (NLOHMANN_DEFINE_TYPE_INTRUSIVE) must be placed in the public section;
 *   ② Non-intrusive macro (NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE) is defined outside the class;
 *   ③ Field order must exactly match macro parameters;
 *   ④ Date fields can use nlohmann::json custom adl_serializer to handle ISO 8601 format.
 */

Best Practices

FAQ

Dépannage

Glossaire

struct / class

Keywords in C++ for defining composite data types. This tool generates struct, e.g., struct User { int64_t id; std::string name; };. struct and class are nearly equivalent in C++ (different default access: struct members default to public, class members default to private); the tool defaults to struct. For deserialization scenarios, using struct is cleaner and more intuitive; if you need encapsulated private members + accessor methods, manually change to class.

std::string

The C++ standard library string type (ownership semantics), defined in <string>. This tool automatically maps JSON string fields to std::string, e.g., std::string name. Note that std::string differs from C's char* / char[]: std::string manages memory automatically, supports operator overloading (+, ==, <), but performs best for small to medium length strings; for extremely long strings (like log lines 1KB+), consider std::string_view or custom buffers.

std::vector<T>

The C++ standard library dynamic array container (<vector>), equivalent to Java's ArrayList, Python's list, JavaScript's Array. This tool automatically maps JSON array fields to std::vector<T>, e.g., std::vector<std::string> tags. Advantages: contiguous memory, O(1) random access, amortized O(1) tail append; disadvantages: O(n) mid-insertion. Use std::array<T, N> (stack-allocated) when fixed-size arrays are needed.

std::optional<T>

The C++17+ standard library optional value wrapper type (<optional>), indicating a value may not exist. Typical usage: std::optional<std::string> nickname; if (nickname) { use(*nickname); }. This tool maps JSON fields that may be null to std::optional<T>, e.g., std::optional<std::string> nickname. If your project must use C++11/14, replace with boost::optional<T> (API nearly identical).

int64_t / double

int64_t is a fixed-width 64-bit integer type alias in <cstdint>, equivalent to long long, cross-platform guaranteed 8 bytes. double is C++'s double-precision floating point type (IEEE 754 double / binary64, approximately 15-17 significant digits). This tool uniformly maps JSON integers to int64_t and floats to double, avoiding precision issues from cross-platform long size inconsistencies (Windows long is 32-bit, Linux long is 64-bit). Use long double or decimal libraries for precise floating point (financial calculations).

nlohmann::json

One of the most popular JSON libraries in the C++ ecosystem, also known as nlohmann/json, released by Niels Lohmann of Germany. Its core idea maps JSON data structures to C++ standard library types (std::map, std::vector, std::string), and deserialization can be done in one line via j.get<T>(). Code generated by this tool works with nlohmann/json, using macros like NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE for automatic deserialization. Single-header dependency, rich documentation, API consistent with STL style, it is the first choice for most C++ projects.

rapidjson

Tencent's open-source high-performance JSON library (C++), about 5k lines of code, performance about 3-5x that of nlohmann::json. Supports both SAX (streaming) and DOM (Document Object Model) parsing styles, with specialized acceleration for SIMD instructions (such as SSE42). Typical scenarios: financial trading market data push, game engine object serialization, embedded high-performance logging. Structs generated by this tool can serve as target models for rapidjson Document / GenericValue deserialization, but since rapidjson lacks template reflection, manual GetObject / GetString field extraction is required.

Web Worker / quicktype-core

Web Worker is a browser-provided background thread API that executes in parallel with the main thread, cannot access the main thread's DOM, and only communicates via postMessage. quicktype-core is an open-source JSON → multi-language code generator library (GitHub: quicktype/quicktype), supporting over a dozen languages including C++/Java/TypeScript/Rust/Go/Python/Swift. This tool renders header-only struct code for C++ locally in the browser based on quicktype-core; raw data is never uploaded to any server, all parsing, generation, and downloads happen in-browser. Worker loading quicktype-core avoids blocking the UI main thread.

snake_case / camelCase / PascalCase

Three mainstream field naming conventions: snake_case (user_name, preferred for C / Python / DB), camelCase (userName, preferred for Java / JS), PascalCase (UserName, preferred for C# / Rust struct fields). This tool defaults to keeping original JSON field names (usually snake_case); you can manually adjust after generation and add NLOHMANN macros to declare mappings. Note C++ public field naming conventions recommend camelCase or snake_case; PascalCase is mainly for class names (Google C++ Style), not recommended for members; snake_case is naturally compatible with MySQL column names.

NLOHMANN_DEFINE_TYPE_INTRUSIVE

A macro provided by the nlohmann/json library for declaring JSON serialization field mappings inside a class. Syntax: NLOHMANN_DEFINE_TYPE_INTRUSIVE(ClassName, member1, member2, ...), must be placed in the public section (to let the macro access private fields). The non-intrusive version NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE is placed outside the class, no class modification needed. Structs generated by this tool do not automatically add such macros; add manually when needed to declare correspondences between JSON keys and C++ members. If JSON field names match C++ member names, you can omit this macro and directly use j.get<T>().

JSON Type to C++ Type Mapping Quick Reference

The tool automatically infers corresponding C++ types based on JSON value types:

Common C++ JSON Parser Selection Comparison Table

Comparison of mainstream JSON parsing libraries in the C++ ecosystem; choose according to project needs:

Common C++ Standard Library Types to JSON Quick Reference

Overview of core types in the C++ standard library corresponding to JSON fields, for quick developer reference:

Privacy & Security

Toutes les opérations de cet outil JSON vers C++ s'effectuent entièrement dans votre navigateur: analyse JSON, génération de structs C++ et téléchargements s'exécutent côté client via JavaScript (Web Worker + quicktype-core). Aucun contenu JSON, fichier téléversé ou code généré n'est envoyé sur le réseau. Les téléversements utilisent FileReader natif directement en mémoire. Pas de suivi Cookies, pas de collecte de données. En fermant la page, tout est effacé de la mémoire.

Authoritative References

• nlohmannnlohmann/json GitHub Repository (nlohmann/json)
• cppreferencecppreference - std::optional
• cppreferencecppreference - std::vector
• TencentRapidJSON GitHub Repository (Tencent)
• BoostBoost.JSON Official Documentation
• ISO C++ISO C++ Official Standard - isocpp.org