JSON sang C++

Đề xuất Liên quan

Về JSON sang C++: Biến dữ liệu JSON thành cấu trúc C++ có thể biên dịch

Trường hợp sử dụng

• Tích hợp REST API: Chuyển phản hồi JSON trả về từ backend thành struct C++, giải tuần tự hóa yêu cầu HTTP kiểu mạnh với nlohmann::json / cpr
• Định nghĩa giao diện microservice: Chuyển JSON mẫu yêu cầu của dịch vụ gRPC / HTTP thành kiểu C++, thống nhất định nghĩa mô hình phía máy chủ
• Nhúng & IoT: Chuyển dữ liệu cảm biến JSON được báo cáo từ thiết bị thành struct C++, phân tích bản tin MQTT / HTTP với ArduinoJson hoặc ESP-IDF JSON Parser
• Phát triển game: Chuyển JSON cấu hình màn chơi, thuộc tính nhân vật thành struct C++, thuận tiện cho các engine như Unreal Engine hoặc Cocos2d-x đọc file dữ liệu .json
• Giao dịch tần suất cao tài chính: Chuyển phản hồi giao diện JSON của sàn giao dịch (như OKX / Binance / thị trường Xueqiu) thành struct C++, phân tích tốc độ nano giây với rapidjson
• Client C++ Qt: Chuyển cấu hình JSON của máy chủ thành struct C++, tải dữ liệu GUI với QJsonObject / QJsonDocument
• Boost.JSON / Boost.Beast: Chuyển phản hồi JSON của dịch vụ HTTP thành struct C++, giải tuần tự hóa với Boost.JSON để viết backend web
• RTOS nhúng: Chuyển JSON cấu hình hệ thống FreeRTOS / Zephyr thành struct C++, đọc tham số firmware với cJSON
• Thuật toán / định lượng: Chuyển cấu hình JSON của hệ thống backtesting thành struct C++, thuận tiện quản lý cấu hình thử nghiệm A/B và truy vết phiên bản
• Di chuyển cơ sở dữ liệu: Chuyển tài liệu JSON xuất từ MongoDB / PostgreSQL thành mô hình C++, làm tham chiếu cho trường thực thể cpp-httplib / libpqxx
• Âm thanh/video / đa phương tiện: Chuyển JSON cấu hình FFmpeg / GStreamer thành struct C++, thuận tiện đọc tham số đường ống media
• Mô phỏng & mô hình hóa: Chuyển cấu hình đầu vào JSON của hệ thống mô phỏng thành struct C++, thống nhất định dạng dữ liệu đầu vào giữa các mô hình con khác nhau
• Xây dựng dữ liệu kiểm thử: Chuyển JSON fixture thực từ phản hồi backend thành kiểu C++, thực hiện khẳng định có cấu trúc trong kiểm thử đơn vị Google Test / Catch2
• Phân tích nhật ký có cấu trúc: Chuyển nhật ký JSON được thu thập bởi ELK / Loki thành kiểu C++, thuận tiện cho việc lọc và quy tắc cảnh báo
• Di chuyển trung tâm cấu hình: Chuyển cấu hình JSON của Apollo / Nacos / Consul thành kiểu C++, sử dụng cho tải nóng cấu hình phía máy chủ
• Hợp tác đa ngôn ngữ: Backend C++ tích hợp với frontend TypeScript / Java, cùng một JSON được chuyển thành struct C++ và interface TS / Java POJO tương ứng để giữ nhất quán hai phía
• Giảng dạy & đào tạo: Trong khóa học C++, chuyển JSON mẫu thành struct, trình diễn quá trình giải tuần tự hóa nlohmann::json và khái niệm lập trình template metaprogramming
• Chuyển đổi đặt tên trường: Sau khi chuyển phản hồi JSON API snake_case thành cấu trúc C++, thủ công thêm NLOHMANN_DEFINE_TYPE_INTRUSIVE để thực hiện ánh xạ trường

Cách Sử dụng

1. Dán nội dung JSON vào trình soạn thảo bên trái (khuyến nghị đối tượng JSON), hoặc nhấp nút tải lên để chọn file .json / .txt
2. Công cụ sử dụng quicktype-core qua Web Worker để tự động chuyển đổi trong vòng 400ms, bên phải hiển thị code header C++ với std::string / std::vector<T> / class lồng nhau
3. Nếu có lỗi định dạng JSON sẽ hiển thị thông báo đỏ, nhấp nút 'Sửa JSON' để tự động sửa các vấn đề phổ biến như dấu phẩy cuối, dấu nháy đơn rồi thử lại
4. Kiểm tra xem tên struct / class tạo ra, kiểu trường có phù hợp với kỳ vọng không; nếu cần điều chỉnh có thể sửa tên key của JSON nguồn rồi chuyển đổi lại
5. Nhấp 'Sao chép' để dán code vào file .h / .hpp trong IDE, giải tuần tự hóa phản hồi API thực với nlohmann/json hoặc rapidjson; hoặc nhấp 'Tải xuống' để lưu thành model.h / model.hpp

Tính năng

• Chuyển đổi cục bộ trình duyệt: Phân tích JSON và tạo code C++ đều hoàn thành trong trình duyệt qua Web Worker + quicktype-core, dữ liệu gốc không tải lên máy chủ nào
• Đầu ra kiểu nlohmann::json: Tự động tạo struct kiểu STL như std::string / std::vector<T> / double / int64_t / bool, theo thói quen giải tuần tự hóa nlohmann::json, có thể include <nlohmann/json.hpp> trực tiếp để phân tích
• Tương thích rapidjson: Struct C++ thuần tạo ra không phụ thuộc thư viện bên thứ ba, có thể sử dụng với rapidjson Document / GenericValue cho các tình huống phân tích hiệu suất cao
• Suy luận kiểu tự động: Chuỗi JSON ánh xạ std::string, số nguyên ánh xạ int64_t / long long, số thực ánh xạ double, boolean ánh xạ bool, mảng ánh xạ std::vector<T>, đối tượng lồng nhau ánh xạ class / struct độc lập
• Tự động tách đối tượng lồng nhau: JSON lồng nhau tự động tạo class / struct độc lập (đặt tên PascalCase), tránh định nghĩa lặp lại cùng một kiểu
• Tự động xử lý std::vector và std::optional: Mảng JSON chuyển thành std::vector<T>, trường có thể null chuyển thành std::optional<T> dự phòng, tuân thủ thực tiễn C++17 / C++20 hiện đại
• Tự động chuyển đổi với debounce 400ms: Sau khi dán JSON tự động kích hoạt chuyển đổi, xem trước code header C++ thời gian thực ở bên phải, giảm thời gian chờ và nhấp chuột thừa
• Sửa lỗi JSON một cú nhấp: Tự động sửa các lỗi định dạng phổ biến như dấu phẩy cuối, dấu nháy đơn, thiếu dấu nháy, tiếp tục tạo code sau khi sửa thành công
• Tô màu cú pháp code + sao chép một cú nhấp: CodeMirror bên phải hiển thị tô màu cú pháp C++, sao chép toàn bộ file header một cú nhấp, hoặc tải xuống dưới dạng file .h / .hpp để đưa trực tiếp vào dự án
• Lịch sử nhập localStorage + chia cột responsive: Tự động lưu nhập gần đây, khôi phục nhanh sau khi làm mới hoặc đóng trang nhầm; dán JSON bên trái, xem code C++ bên phải, hỗ trợ kéo điều chỉnh độ rộng bảng điều khiển, thích ứng màn hình lớn và di động
• Sản phẩm header-only không phụ thuộc: File .h / .hpp tạo ra ở dạng header-only, có thể include đơn file vào bất kỳ dự án C++ tiêu chuẩn nào, không cần cấu hình xây dựng bổ sung để sử dụng với nlohmann::json / rapidjson / Boost.JSON
• Tích hợp sẵn snake_case sang camelCase: Có thể tự động chuyển trường snake_case trong JSON thành tên trường camelCase được đề xuất cho C++, kết hợp với NLOHMANN_DEFINE_TYPE_INTRUSIVE để duy trì ánh xạ tuần tự hóa snake_case

Ví dụ mã

// model.hpp（由本工具生成）
// #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) 解析 JSON 字符串
    json j = json::parse(raw);

    // 2) 强类型反序列化为本工具生成的 struct
    User u = j.get<User>();

    // 3) 访问字段
    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;
}

/*
 * 编译（CMake 项目）：
 *   find_package(nlohmann_json REQUIRED)
 *   target_link_libraries(my_app PRIVATE nlohmann_json::nlohmann_json)
 * 编译（vcpkg）：
 *   vcpkg install nlohmann-json
 * 单文件集成：
 *   直接下载 https://github.com/nlohmann/json/releases 的 json.hpp
 */

#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 解析
    rapidjson::Document doc;
    doc.Parse(raw);

    // 2) 构造本工具生成的 struct 并手动填充
    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) 使用填充后的 struct
    std::cout << u.name << ", tags=" << u.tags.size() << std::endl;
    return 0;
}

/*
 * rapidjson 高性能小贴士：
 *   ① 配合 rapidjson::MemoryPoolAllocator 与 StringBuffer 可进一步提速；
 *   ② 高频场景可使用 SAX 风格的 Reader / Writer 直接流式处理；
 *   ③ 启用 RAPIDJSON_SSE42 / RAPIDJSON_SIMD 宏可使用 CPU SIMD 指令加速。
 */

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

// 假设本工具生成字段为 snake_case：user_name, created_at
// 实际工程中重命名为 camelCase 时添加如下宏
struct UserProfile {
    int64_t id;
    std::string userName;       // JSON 中是 "user_name"
    std::string emailAddress;   // JSON 中是 "email_address"
    std::string createdAt;      // JSON 中是 "created_at"
};

// 用 NLOHMANN_DEFINE_TYPE_INTRUSIVE 在类内部声明映射
// 注意：必须放在 public 区域
// 
// NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// 或者用非侵入式宏（避免修改类本身）：
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)

// 用法：
int main() {
    nlohmann::json j = {
        {"id", 1},
        {"user_name", "Alice"},
        {"email_address", "a**@***********"},
        {"created_at", "2026-07-14T10:00:00.000Z"}
    };

    UserProfile p = j.get<UserProfile>();
    // 序列化时也会按原字段名输出
    std::cout << j.dump(2) << std::endl;
    return 0;
}

/*
 * 提示：
 *   ① 侵入式宏（NLOHMANN_DEFINE_TYPE_INTRUSIVE）必须放在 public 区域；
 *   ② 非侵入式宏（NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE）定义在类外；
 *   ③ 字段顺序要与宏参数严格一致；
 *   ④ 日期字段可改用 nlohmann::json 自定义 adl_serializer 处理 ISO 8601 格式。
 */

Best Practices

Câu hỏi Thường gặp

Xử lý sự cố

Thuật ngữ

struct / class

Từ khóa trong C++ dùng để định nghĩa kiểu dữ liệu phức hợp. Công cụ này tạo ra chính là struct, ví dụ struct User { int64_t id; std::string name; }. Trong C++ struct và class gần như tương đương (quyền truy cập mặc định khác nhau: thành viên struct mặc định public, thành viên class mặc định private), công cụ mặc định tạo struct. Trong tình huống giải tuần tự hóa, sử dụng struct ngắn gọn và trực quan hơn; nếu cần đóng gói thành viên private + phương thức truy cập, có thể thủ công đổi thành class.

std::string

Kiểu chuỗi của thư viện chuẩn C++ (ngữ nghĩa sở hữu), được định nghĩa trong <string>. Công cụ này tự động ánh xạ trường chuỗi JSON thành std::string, ví dụ std::string name. Lưu ý std::string khác với char* / char[] ngôn ngữ C: std::string tự động quản lý bộ nhớ, hỗ trợ nạp chồng toán tử (+, ==, <), nhưng hiệu suất tốt nhất chỉ khi xử lý chuỗi độ dài nhỏ đến trung bình; chuỗi cực dài (như toàn bộ dòng nhật ký 1KB+) khuyến nghị改用 std::string_view hoặc buffer tùy chỉnh.

std::vector<T>

Container mảng động của thư viện chuẩn C++ (<vector>), tương đương với ArrayList của Java, list của Python, Array của JavaScript. Công cụ này tự động ánh xạ trường mảng JSON thành std::vector<T>, ví dụ std::vector<std::string> tags. Ưu điểm: bộ nhớ liên tục, truy cập ngẫu nhiên O(1), thêm cuối O(1) phân rã; nhược điểm: chèn giữa O(n). Khi cần mảng kích thước cố định có thể sử dụng std::array<T, N> (phân bổ trên stack).

std::optional<T>

Kiểu bao bọc giá trị tùy chọn của thư viện chuẩn từ C++17 (<optional>), biểu thị giá trị có thể không tồn tại. Cách sử dụng điển hình: std::optional<std::string> nickname; if (nickname) { use(*nickname); }. Công cụ này ánh xạ trường JSON có thể null thành std::optional<T>, ví dụ std::optional<std::string> nickname. Nếu dự án của bạn phải sử dụng C++11/14, có thể thay thế bằng boost::optional<T> (#include <boost/optional.hpp>), API gần như nhất quán.

int64_t / double

int64_t là bí danh kiểu số nguyên 64 bit chiều rộng cố định trong <cstdint>, tương đương long long, đảm bảo 8 byte đa nền tảng. double là kiểu số thực dấu phẩy động kép của C++ (IEEE 754 kép / binary64, khoảng 15-17 chữ số có nghĩa). Công cụ này nhất quán ánh xạ số nguyên JSON thành int64_t, số thực thành double, tránh vấn đề độ chính xác do sự không nhất quán kích thước long đa nền tảng (Windows long là 32 bit, Linux long là 64 bit). Khi cần số thực chính xác (tính toán tài chính) có thể sử dụng long double hoặc thư viện decimal.

nlohmann::json

Một trong những thư viện JSON phổ biến nhất trong hệ sinh thái C++, còn gọi là nlohmann/json, do Niels Lohmann phát hành. Ý tưởng cốt lõi của nó là ánh xạ cấu trúc dữ liệu JSON thành kiểu thư viện chuẩn C++ (như std::map, std::vector, std::string), khi giải tuần tự hóa có thể hoàn thành với một dòng j.get<T>(). Code tạo bởi công cụ này có thể sử dụng cùng nlohmann/json, sử dụng macro như NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE để triển khai giải tuần tự hóa tự động. Phụ thuộc đơn header, tài liệu phong phú, API nhất quán với phong cách STL, là lựa chọn hàng đầu cho hầu hết các dự án C++.

rapidjson

Thư viện JSON hiệu suất cao mã nguồn mở của Tencent (C++), số lượng code khoảng 5k dòng, hiệu suất gấp khoảng 3-5 lần nlohmann::json. Hỗ trợ hai kiểu phân tích SAX (streaming) và DOM (mô hình đối tượng tài liệu), có triển khai tăng tốc đặc biệt cho lệnh SIMD (như SSE42). Tình huống điển hình: đẩy thị trường giao dịch tài chính, tuần tự hóa đối tượng engine game, nhật ký hiệu suất cao nhúng. Struct tạo bởi công cụ này có thể làm mô hình đích cho giải tuần tự hóa rapidjson Document / GenericValue, nhưng vì rapidjson không có phản xạ template, cần thủ công GetObject / GetString để trích xuất trường.

Web Worker / quicktype-core

Web Worker là API luồng nền được cung cấp bởi trình duyệt, thực thi song song với luồng chính, không thể truy cập DOM của luồng chính, chỉ có thể giao tiếp qua postMessage. quicktype-core là thư viện tạo code đa ngôn ngữ JSON mã nguồn mở (GitHub: quicktype/quicktype), hỗ trợ hơn mười ngôn ngữ bao gồm C++/Java/TypeScript/Rust/Go/Python/Swift. Công cụ này dựa trên quicktype-core để kết xuất code cấu trúc header-only cho C++ cục bộ trên trình duyệt, dữ liệu gốc không tải lên máy chủ nào, tất cả phân tích, tạo, tải xuống đều hoàn thành trong trình duyệt. Worker tải quicktype-core để tránh chặn luồng chính UI.

snake_case / camelCase / PascalCase

Ba phong cách đặt tên trường chính: snake_case (user_name, ưu tiên C / Python / DB), camelCase (userName, ưu tiên Java / JS), PascalCase (UserName, ưu tiên trường struct C# / Rust). Công cụ này mặc định giữ nguyên tên trường gốc JSON (thường là snake_case), bạn có thể điều chỉnh thủ công sau khi tạo và thêm macro NLOHMANN để khai báo ánh xạ. Lưu ý quy phạm đặt tên trường công khai C++ khuyến nghị camelCase hoặc snake_case, PascalCase chủ yếu dùng cho tên lớp (Google C++ Style), không khuyến nghị cho thành viên; snake_case tương thích tự nhiên với tên cột mySQL.

NLOHMANN_DEFINE_TYPE_INTRUSIVE

Macro được cung cấp bởi thư viện nlohmann/json, dùng để khai báo ánh xạ trường tuần tự hóa JSON bên trong lớp. Cú pháp là NLOHMANN_DEFINE_TYPE_INTRUSIVE(ClassName, member1, member2, ...), phải được đặt trong khu vực public (để macro truy cập trường private). Phiên bản không xâm nhập NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE đặt bên ngoài lớp, không cần sửa đổi bản thân lớp. Struct tạo bởi công cụ này không tự động thêm macro này, khi cần hãy thủ công thêm để khai báo quan hệ tương ứng giữa khóa JSON và thành viên C++. Nếu tên trường JSON trùng với tên thành viên C++, có thể bỏ qua macro này và trực tiếp sử dụng j.get<T>().

Bảng tra cứu nhanh ánh xạ kiểu JSON sang kiểu C++

Công cụ tự động suy luận kiểu C++ tương ứng dựa trên kiểu giá trị JSON:

Bảng so sánh lựa chọn bộ phân tích JSON C++ phổ biến

So sánh các thư viện phân tích JSON chính trong hệ sinh thái C++, lựa chọn theo nhu cầu dự án:

Bảng tra cứu nhanh kiểu thư viện chuẩn C++ phổ biến và tương ứng JSON

Tổng hợp các kiểu cốt lõi trong thư viện chuẩn C++ tương ứng với trường JSON, thuận tiện cho nhà phát triển tra cứu nhanh:

Privacy & Security

Tất cả thao tác của công cụ JSON sang C++ này hoàn thành cục bộ trên trình duyệt của bạn: phân tích JSON, tạo cấu trúc C++, tải xuống file đều thực thi phía khách qua JavaScript trình duyệt (Web Worker + quicktype-core), không gửi nội dung JSON, file đã tải lên hoặc code tạo ra đến bất kỳ máy chủ nào qua mạng. Tải lên file sử dụng API FileReader gốc của trình duyệt để đọc trực tiếp vào bộ nhớ, không đi qua bất kỳ dịch vụ trung gian nào. Không sử dụng theo dõi Cookie, không thu thập bất kỳ dữ liệu nhập hoặc sử dụng nào của người dùng. Sau khi đóng hoặc làm mới trang, tất cả nội dung nhập và xuất tự động bị xóa khỏi bộ nhớ. Thích hợp xử lý JSON chứa khóa API, token, dữ liệu nghiệp vụ nhạy cảm.

Authoritative References

• nlohmannKho GitHub nlohmann/json (nlohmann/json)
• cppreferencecppreference - std::optional
• cppreferencecppreference - std::vector
• TencentKho GitHub RapidJSON (Tencent)
• BoostTài liệu chính thức Boost.JSON
• ISO C++Chuẩn chính thức ISO C++ - isocpp.org