JSON para C++

Sugestões Relacionadas

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

Casos de uso

• 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

Como Usar

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

Recursos

• 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

Exemplos de Código

// 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

Perguntas frequentes

Solução de Problemas

Glossário

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

Todas as operações desta ferramenta JSON para C++ são concluídas inteiramente no seu navegador: análise JSON, geração de structs C++ e downloads são executados no lado do cliente via JavaScript (Web Worker + quicktype-core). Nenhum conteúdo JSON, arquivos enviados ou código gerado é enviado pela rede. Uploads usam FileReader nativo diretamente na memória. Sem rastreamento de Cookies, sem coleta de dados. Ao fechar a página, tudo é apagado da memória.

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