Brak zawartości
Darmowe narzędzie online JSON na C++. Wklej JSON, aby automatycznie wygenerować kompilowalny kod pliku nagłówkowego C++ struct/class, odpowiedni do deserializacji odpowiedzi API za pomocą nlohmann/json lub rapidjson, zagnieżdżone obiekty są automatycznie rozdzielane na niezależne klasy, std::vector i std::optional są obsługiwane automatycznie, działanie całkowicie lokalne w przeglądarce.
JSON na C++ to proces konwersji danych w formacie JSON (obiektów lub tablic) na definicje typów struct/class C++. C++ jest silnie typowanym językiem programowania systemowego, szeroko stosowanym w usługach backendowych, silnikach gier, firmware'ach systemów wbudowanych, handlu kwantytatywnym, wysokowydajnych usługach i klientach desktopowych. Podczas tworzenia często trzeba przekonwertować przykładowy JSON z dokumentacji API lub rzeczywistych odpowiedzi na typy C++, ręczne pisanie struktur jest nie tylko powtarzalne, ale także łatwo popełnić błąd w typie pola, celem tego narzędzia jest zautomatyzowanie tego procesu. W przeciwieństwie do Java, Python, JavaScript, C++ nie ma natywnego wsparcia dla dynamicznych struktur takich jak JSON, więc «JSON na C++» od dawna jest uważane w świecie inżynierii za «powtarzalną, ale nieodzowną» pracę.
To narzędzie działa lokalnie w przeglądarce na podstawie quicktype-core, używając renderera CPP i opcji renderowania just-types, aby wygenerować kod struktur dla C++ oparty na std::string/std::vector<T>/std::optional<T>. Generowany jest standardowy kod C++ header-only, niezależny od żadnych bibliotek parsowania JSON trzecich, można go bezpośrednio załączyć #include do dowolnego projektu C++17/C++20. W połączeniu z parserami nlohmann::json lub rapidjson można szybko dokonać deserializacji odpowiedzi API. Cały proces renderowania jest wykonywany asynchronicznie w przeglądarce przez Web Worker, główny wątek pozostaje płynny i responsywny.
Wnioskowanie typów jest rdzeniem JSON na C++. Narzędzie mapuje podstawowe typy JSON na standardowe typy C++: ciągi na std::string, liczby całkowite na int64_t (kompatybilne z long long, unikając różnic w rozmiarze long między platformami), liczby zmiennoprzecinkowe na double, wartości logiczne na bool, tablice na std::vector<T>, zagnieżdżone obiekty na niezależne struktury/klasy, wartości null na std::optional<T>. W przypadku zagnieżdżonych obiektów narzędzie automatycznie tworzy nową klasę dla każdego poziomu i nazywa ją według PascalCase, na przykład pole address wygeneruje strukturę Address, obiekty w tablicy items wygenerują strukturę Item. Ten sam zagnieżdżony poziom JSON jest generowany tylko raz, bez powtarzających się definicji.
W przeciwieństwie do niektórych narzędzi online wymagających wysłania JSON na serwer w celu przetworzenia, wszystkie obliczenia tego narzędzia odbywają się w przeglądarce. quicktype-core jest ładowany i wykonywany przez Web Worker, analiza JSON, wnioskowanie typów, generowanie kodu C++ i pobieranie plików odbywają się lokalnie, żadne dane nie są wysyłane na żaden serwer. Jest to szczególnie ważne dla JSON zawierającego klucze API, pola prywatności użytkownika lub nieopublikowane struktury biznesowe, po zamknięciu strony dane są usuwane z pamięci. Niezależnie od środowiska sieciowego firmy, wymagań audytu wewnętrznego czy scenariuszy rozwoju offline, to narzędzie zapewnia taką samą wiarygodność jak narzędzie wiersza poleceń quicktype.
Wygenerowany kod zwykle wymaga użycia z parserem JSON. Istnieją dwa główne wybory: ① nlohmann::json (zalecane, wprowadzenie pojedynczego nagłówka, przyjazny interfejs serializacji szablonowej, składnia podobna do nlohmann::json j = nlohmann::json::parse(str); User u = j.get<User>();); ② rapidjson (wysokowydajne parsowanie w stylu SAX/DOM, odpowiednie dla ekstremalnych scenariuszy, takich jak finanse, gry, wymaga ręcznego wyodrębniania pól za pomocą GetObject). W przypadku systemów wbudowanych można również użyć ArduinoJson (ograniczone zasoby) lub cJSON (interfejs w stylu C). Kod tego narzędzia jest kompatybilny ze wszystkimi głównymi bibliotekami JSON C++, nie jest związany na stałe z żadnym ekosystemem.
Należy zauważyć, że automatycznie wygenerowany kod jest punktem wyjścia, a nie końcem. Narzędzie wnioskuje typy na podstawie przykładowego JSON, nie może ocenić precyzyjnych typów biznesowych (np. typy semantyczne, takie jak URL, Email, ID, są jednolicie wnioskowane jako std::string). W przypadku pól JSON snake_case, pola struktury C++ są generowane zachowując oryginalną postać, może być konieczne ręczne dodanie NLOHMANN_DEFINE_TYPE_INTRUSIVE lub NLOHMANN_JSON_FROM/NLOHMANN_JSON_TO w celu zadeklarowania relacji mapowania. Zaleca się traktowanie wygenerowanego wyniku jako szkicu, a następnie dostosowanie nazw pól, typów i adnotacji serializacji zgodnie ze specyfikacją projektu. Ten przepływ pracy «AI pisze szkic + inżynier recenzuje» jest również rzeczywistym tempem wielu zespołów C++.
W scenariuszach współpracy międzyzespołowej JSON na C++ jest również mostem do ujednolicania modeli danych. Frontend używa JSON na TypeScript, backend używa JSON na Java/Go/Rust, systemy wbudowane i usługi wydajnościowe używają JSON na C++, cztery strony generują swoje definicje typów z tego samego przykładowego JSON, co maksymalizuje zgodność pól. To narzędzie jest «stroną C++» w tym przepływie pracy, może być używane jednocześnie z innymi narzędziami na stronie do konwersji JSON na TypeScript/Java/Rust/Go/Python.
Podsumowując jednym zdaniem: jeśli Twój kod działa w projektach C++ wrażliwych na wydajność, silnie typowanych, z bogatym ekosystemem, i musisz szybko wprowadzić dynamiczne dane, takie jak JSON, do silnie typowanego świata, to narzędzie jest bezpośrednim punktem wejścia do kompilacji przykładowego JSON na struktury C++.
Umieść wygenerowaną strukturę User w .hpp, współpracuj z nlohmann::json w celu deserializacji (zalecane dla nowoczesnych projektów C++17/20).
// model.hpp (wygenerowany przez to narzędzie)
// #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) Analiza ciągu JSON
json j = json::parse(raw);
// 2) Silnie typowana deserializacja do struktury wygenerowanej przez narzędzie
User u = j.get<User>();
// 3) Dostęp do pól
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;
}
/*
* Kompilacja (projekt CMake):
* find_package(nlohmann_json REQUIRED)
* target_link_libraries(my_app PRIVATE nlohmann_json::nlohmann_json)
* Kompilacja (vcpkg):
* vcpkg install nlohmann-json
* Integracja pojedynczego pliku:
* Pobierz bezpośrednio json.hpp z wydań https://github.com/nlohmann/json/releases
*/rapidjson nie obsługuje automatycznej deserializacji do niestandardowych struktur, wymaga ręcznego wyodrębniania za pomocą GetObject. Odpowiednie dla wysokowydajnych scenariuszy, takich jak finanse/gry.
#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) Parsowanie DOM rapidjson
rapidjson::Document doc;
doc.Parse(raw);
// 2) Konstrukcja struktury wygenerowanej przez narzędzie i ręczne wypełnienie
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) Użycie wypełnionej struktury
std::cout << u.name << ", tags=" << u.tags.size() << std::endl;
return 0;
}
/*
* Wskazówki dotyczące wysokiej wydajności rapidjson:
* ① Współpraca z rapidjson::MemoryPoolAllocator i StringBuffer może dodatkowo przyspieszyć;
* ② W scenariuszach wysokiej częstotliwości można użyć Reader/Writer w stylu SAX do bezpośredniego przetwarzania strumieniowego;
* ③ Włączenie makr RAPIDJSON_SSE42/RAPIDJSON_SIMD pozwala na użycie instrukcji SIMD procesora do przyspieszenia.
*/Gdy pola JSON są w formacie snake_case, a członkowie C++ mają używać camelCase/PascalCase, zadeklaruj mapowanie za pomocą makr nlohmann/json.
#include <nlohmann/json.hpp>
#include <string>
#include <cstdint>
// Załóżmy, że narzędzie wygenerowało pola snake_case: user_name, created_at
// Podczas zmiany nazw na camelCase w rzeczywistym projekcie dodaj następujące makra
struct UserProfile {
int64_t id;
std::string userName; // W JSON jest "user_name"
std::string emailAddress; // W JSON jest "email_address"
std::string createdAt; // W JSON jest "created_at"
};
// Użyj NLOHMANN_DEFINE_TYPE_INTRUSIVE do zadeklarowania mapowania wewnątrz klasy
// Uwaga: Musi być umieszczone w obszarze public
//
// NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)
// Lub użyj nieinwazyjnego makra (unika modyfikowania samej klasy):
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(UserProfile, id, userName, emailAddress, createdAt)
// Sposób użycia:
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>();
// Podczas serializacji dane wyjściowe są również zgodne z oryginalnymi nazwami pól
std::cout << j.dump(2) << std::endl;
return 0;
}
/*
* Wskazówki:
* ① Makro inwazyjne (NLOHMANN_DEFINE_TYPE_INTRUSIVE) musi być umieszczone w obszarze public;
* ② Makro nieinwazyjne (NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE) jest definiowane poza klasą;
* ③ Kolejność pól musi być ściśle zgodna z parametrami makra;
* ④ Pola dat mogą być obsługiwane za pomocą niestandardowego adl_serializer nlohmann::json w formacie ISO 8601.
*/Większość zespołów zaleca najpierw użycie nlohmann::json, ponieważ jego API jest podobne do STL, podczas deserializacji jedna linia j.get<User>() wystarczy, czytelność jest bardzo wysoka. Przełącz się na rapidjson tylko wtedy, gdy napotkasz wąskie gardło wydajności (np. ekstrakcja milionów pól JSON na sekundę). Struktury wygenerowane przez to narzędzie mogą współpracować z obiema.
Repozytorium nlohmann/jsonRepozytorium rapidjsonUżycie include(FetchContent) + FetchContent_Declare(nlohmann_json URL ...) jest najczystszym sposobem integracji nlohmann/json w CMaker, nie wymaga wstępnej instalacji vcpkg; jeśli nie chcesz konfigurować FetchContent, możesz użyć vcpkg install nlohmann-json lub pobrać bezpośrednio pojedynczy plik json.hpp i załączyć.
Oficjalna dokumentacja CMake FetchContentNarzędzie domyślnie zachowuje oryginalne nazwy pól JSON (snake_case). Jeśli chcesz, aby członkowie C++ byli camelCase lub PascalCase, musisz dodać NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, ...) wewnątrz klasy, aby jawnie mapować klucze JSON na członków C++, w przeciwnym razie deserializacja się nie powiedzie.
Dokumentacja NLOHMANN_DEFINE_TYPE_INTRUSIVEC++17+ bezpośrednio używa std::optional<T>; projekty C++11/14 zastępują boost::optional<T> (#include <boost/optional.hpp>); projekty w stylu C używają cJSON + pól wartowniczych (-1, pusty ciąg) do reprezentowania wartości null. Należy zauważyć, że interfejs std::optional i boost::optional nieco się różni (has_value() vs is_initialized()).
cppreference std::optionalNa urządzeniach z bardzo małą pamięcią RAM, takich jak Arduino Uno/ESP8266, std::vector i std::string zwykle powodują OOM. Zamiast tego użyj ArduinoJson 6.x + StaticJsonDocument<pojemność>, aby ograniczyć bufor, zastąp std::vector<T> stałym rozmiarem std::array<T, N>, a std::string stałym ciągiem const char* + długość.
Dokumentacja ArduinoJsonWszystkie parsowanie, generowanie kodu i pobieranie plików tego narzędzia odbywa się lokalnie w przeglądarce za pomocą Web Worker, oryginalny JSON nie jest wysyłany na żaden serwer. Ale nadal zaleca się: ① Wewnętrzne modele biznesowe najpierw zdesensytyzuj (usuń token/numer telefonu itp.); ② Zamknięcie strony czyści pamięć; ③ W scenariuszach zgodności w dużych firmach zaleca się przetwarzanie JSON zawierającego informacje o klientach za pomocą lokalnego wiersza poleceń quicktype w IDE.
JSON z ponad 6 poziomami zagnieżdżenia zaleca się zrefaktoryzować po stronie źródłowej lub ręcznie podzielić głęboko zagnieżdżone struktury na struktury pośrednie po wygenerowaniu przez to narzędzie, aby poprawić czytelność i szybkość kompilacji. Głębokie zagnieżdżenie prowadzi do zbyt głębokiej instancjacji szablonu, niektóre stare kompilatory (poniżej GCC 6) zgłaszają błąd «przekroczono głębokość instancjacji szablonu».
Kod wygenerowany przez to narzędzie jest zasadniczo C++ (używa funkcji C++, takich jak std::optional/szablony), zaleca się użycie rozszerzenia .hpp oznaczającego «nagłówek C++», aby odróżnić od .h nagłówków C. W projektach CMake: set_target_properties(target PROPERTIES CXX_EXTENSIONS ON); CMake może również automatycznie rozpoznać, czy kompilować za pomocą gcc czy g++ na podstawie .h vs .hpp, maksymalnie unikając problemu, że szablony header-only nie są ponownie instancjonowane.
Specyfikacja rozszerzeń plików GCCRozpoznawanie typów plików CMakeWklej zawartość JSON do edytora po lewej stronie (obsługuje również przeciąganie lub kliknięcie w celu przesłania pliku .json/.txt), narzędzie automatycznie wywoła quicktype-core w przeglądarce w ciągu 400ms w celu wygenerowania kodu pliku nagłówkowego C++; obszar CodeMirror po prawej stronie wyświetla kod struktury ze std::string/std::vector<T>/zagnieżdżonymi klasami. Jeśli format JSON jest nieprawidłowy, kliknij przycisk «Napraw JSON», aby automatycznie naprawić, a następnie przekonwertować ponownie.
Narzędzie generuje kod struktury header-only zależny tylko od biblioteki standardowej C++ (<string>, <vector>, <optional>, <cstdint>). Podczas parsowania z nlohmann/json wymagane jest dodatkowe #include <nlohmann/json.hpp>; podczas parsowania z rapidjson wymagane jest #include "rapidjson/document.h". Pozostałe standardowe pliki nagłówkowe są deklarowane przez narzędzie w razie potrzeby.
Obsługuje wszystkie legalne struktury JSON: typy podstawowe (null, boolean, number, string), tablice (jednowymiarowe lub wielowymiarowe), zagnieżdżone obiekty (dowolna głębokość). Obiekty JSON generują główną strukturę/klasę, tablice JSON pojawiają się jako std::vector<T> w jakimś polu nadrzędnej struktury. Nie obsługuje literałów obiektów JavaScript, funkcji, Symbol, undefined i innych wartości niebędących JSON.
Ciągi mapują się na std::string; liczby całkowite na int64_t (często używane również long long dla kompatybilności ze starym kodem); liczby zmiennoprzecinkowe na double; wartości logiczne na bool; tablice na std::vector<T>; zagnieżdżone obiekty na niezależne struktury/klasy; wartości null na std::optional<T> (mogą być zabezpieczone nlohmann::json). Szczegółowe reguły mapowania można znaleźć w «Szybkiej tabeli mapowania typów JSON na typy C++» na dole strony.
Wartości null w JSON generują std::optional<T> (dostępne od C++17), co oznacza, że pole może być nieobecne lub mieć nieokreślony typ. Jeśli znasz rzeczywisty typ pola, możesz podać przykładową wartość w źródłowym JSON (np. "field": "" wnioskuje jako std::string), a po wygenerowaniu zmienić na bardziej precyzyjny typ, taki jak std::optional<std::string>, zgodnie z wymaganiami biznesowymi.
Tak. Tablice JSON są jednolicie konwertowane na kontener szablonowy C++ std::vector<T>, typ elementu jest automatycznie wnioskowany na podstawie pierwszego elementu tablicy. Na przykład ["a","b"] generuje std::vector<std::string>, [1,2,3] generuje std::vector<int64_t>, [{...},{...}] generuje std::vector<Item> (gdzie Item jest niezależną strukturą wygenerowaną na podstawie zagnieżdżonego obiektu).
Każdy zagnieżdżony obiekt generuje niezależną strukturę/klasę, reguła nazewnictwa to PascalCase od nazwy pola (np. pole address generuje strukturę Address, obiekty w tablicy items generują strukturę Item). W głównej strukturze zagnieżdżona klasa jest odwoływana przez członka typu std::optional<Address> lub Address. Obiekty o tej samej strukturze są ponownie używane tego samego typu, unikając powtarzających się definicji.
Tak. Typowy przykład użycia: nlohmann::json j; j["root"] = nlohmann::json::parse(raw_json); User u = j.get<User>(); Warunkiem jest, że projekt wprowadził zależność pojedynczego nagłówka nlohmann/json (bezpośrednie dołączenie <nlohmann/json.hpp>) i zdefiniował strukturę User wygenerowaną przez to narzędzie.
Tak. rapidjson wymaga ręcznego napisania kodu wyodrębniania pól typu GetObject. Typowa ścieżka: rapidjson::Document doc; doc.Parse(raw_json); const auto& obj = doc["root"]; std::string id = obj["id"].GetString(); Ponieważ rapidjson nie obsługuje automatycznej deserializacji przez szablony, wygenerowana struktura służy tylko jako odniesienie do modelu danych.
Narzędzie generuje pola C++ zachowując oryginalne nazwy pól JSON (np. user_name), jeśli chcesz, aby członkowie C++ używali camelCase (userName) lub PascalCase (UserName), możesz ręcznie zmodyfikować po wygenerowaniu i dodać makra JSNOMacros (NLOHMANN_DEFINE_TYPE_INTRUSIVE/NLOHMANN_JSON_FROM/NLOHMANN_JSON_TO) w celu określenia mapowania.
Tak. Narzędzie generuje standardowy kod C++ header-only, niezależny od konkretnych frameworków. Podczas parsowania z Qt QJsonObject, użyj struktury jako modelu danych (członkowie oznaczeni Q_GADGET); w przypadku Unreal Engine, użyj z FJsonObjectConverter::JsonObjectStringToUStruct; w przypadku Boost.JSON, przeanalizuj JSON jako boost::json::object, a następnie wyodrębnij pola po kolei.
Całkowicie lokalne działanie w przeglądarce. Cała analiza JSON, generowanie kodu C++ i pobieranie plików odbywa się w przeglądarce za pomocą JavaScript (Web Worker + quicktype-core), wprowadzone dane JSON i wygenerowany kod C++ nie są wysyłane na żaden serwer, nie są również rejestrowane ani buforowane w chmurze. Wrażliwe JSON zawierające klucze API, tokeny, niepubliczne pola biznesowe mogą być bezpiecznie używane, po zamknięciu strony są usuwane.
Nie. Narzędzie jest całkowicie darmowe, nie wymaga rejestracji, logowania ani autoryzacji. Otwórz stronę i używaj, wszystkie funkcje są dostępne lokalnie w przeglądarce, bez ograniczeń liczby wywołań lub rozmiaru pliku (ograniczone pamięcią przeglądarki).
Narzędzie automatycznie sprawdza poprawność JSON, w przypadku błędu po prawej stronie wyświetla czerwony komunikat o błędzie i udostępnia przycisk «Napraw JSON». Po kliknięciu może automatycznie naprawić typowe błędy: dodatkowe przecinki na końcu, zamiana pojedynczych cudzysłowów na podwójne, uzupełnienie cudzysłowów dla kluczy bez cudzysłowów, usunięcie komentarzy itp. Po pomyślnej naprawie kontynuuje generowanie kodu C++.
Wszystkie trzy konwertują JSON na definicje typów w języku docelowym, ale forma wyjściowa jest inna: JSON na C++ generuje struktury/klasy header-only, wymaga dodatkowego napisania kodu deserializacji z nlohmann/json lub rapidjson; JSON na Java generuje pełne klasy POJO z getterami/setterami, można je bezpośrednio skompilować i uruchomić; JSON na Rust generuje struktury z Serde derive, można bezpośrednio deserializować za pomocą serde_json. Wybór zależy od Twojego stosu technologicznego.
Pole wejściowe po lewej stronie jest puste lub zawiera tylko białe znaki. Upewnij się, że wkleiłeś prawidłową zawartość JSON, lub kliknij przycisk przesyłania, aby wybrać plik .json/.txt, możesz również kliknąć przycisk przykładowy, aby załadować wbudowany przykład (zawiera zagnieżdżone pola address/tags).
Typowe przyczyny: dodatkowy przecinek na końcu, użycie pojedynczych cudzysłowów zamiast podwójnych, klucz bez cudzysłowów, zawieranie komentarzy JavaScript. Kliknij przycisk «Napraw JSON», aby automatycznie naprawić niektóre błędy; jeśli nadal nie powiedzie się, najpierw zweryfikuj za pomocą narzędzia formatowania JSON.
Projekt nie używa standardu C++17 lub nowszego. std::optional został wprowadzony w C++17. W CMakeLists.txt ustaw CMAKE_CXX_STANDARD na 17 lub wyższy (lub użyj set(CMAKE_CXX_STANDARD 17)); lub dodaj #include <optional> na górze pliku źródłowego i potwierdź wersję kompilatora.
Narzędzie używa int64_t z <cstdint>, wymaga GCC 4.5+/Clang 3.0+/MSVC 2015+. Sprawdź, czy na górze pliku źródłowego znajduje się #include <cstdint> lub #include <stdint.h>, i potwierdź, że ustawienie standardu C++ CMake jest >= C++11.
Możliwe przyczyny: ① Nazwa pola JSON nie jest całkowicie zgodna z nazwą członka C++ (snake_case vs camelCase); ② Zagnieżdżony obiekt nie został poprawnie obsłużony; ③ Dostęp value() pola std::optional zgłasza wyjątek. Rozwiązanie: dodaj makro NLOHMANN_DEFINE_TYPE_INTRUSIVE, aby jawnie mapować pola, lub użyj j.value("key", default), aby podać wartość domyślną.
rapidjson domyślnie nie weryfikuje typu pola. GetString jest bezpieczny tylko wtedy, gdy pole rzeczywiście istnieje i jest typu ciągu. Poprawione pisanie: if (doc.HasMember("name") && doc["name"].IsString()) { u.name = doc["name"].GetString(); }, unikaj bezpośredniego GetInt/GetString na nieistniejącym kluczu.
Narzędzie wnioskuje typy na podstawie przykładowego JSON, wszystkie liczby całkowite to int64_t, wszystkie ciągi to std::string. Jeśli potrzebujesz bardziej precyzyjnych typów, takich jak int32_t, uint64_t, std::chrono::system_clock::time_point, ręcznie zmień typ pola po wygenerowaniu i upewnij się, że wybrana biblioteka parsowania JSON obsługuje deserializację tego typu.
Ponieważ JSON null nie może wnioskować konkretnego typu, narzędzie bezpiecznie zabezpiecza go jako std::optional<nlohmann::json>. Jeśli znasz rzeczywisty typ pola, możesz podać przykładową wartość w źródłowym JSON (np. "field": "" wnioskuje jako std::string), wygenerować ponownie, a następnie ręcznie zmienić na std::optional<std::string>.
Narzędzie generuje pola C++ zachowując oryginalne nazwy pól JSON (np. user_name). Jeśli chcesz, aby członkowie C++ używali camelCase (userName) jednocześnie poprawnie deserializując JSON snake_case, zapoznaj się z trzecim akapitem codeExamples, używając makr NLOHMANN_DEFINE_TYPE_INTRUSIVE/NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
Możliwe przyczyny: ① CMake nie ustawił standardu C++17/C++20; ② Brakuje plików nagłówkowych, takich jak <optional>/<vector>; ③ Nazwa struktury koliduje z innymi typami w projekcie. Rozwiązanie: dodaj set(CMAKE_CXX_STANDARD 17) w CMakeLists.txt, dodaj odpowiednie nagłówki na górze pliku źródłowego, otocz namespace lub zmień nazwę kolidującej struktury.
Narzędzie automatycznie wnioskuje odpowiadające typy C++ na podstawie typu wartości JSON:
| Przykładowa wartość JSON | Wygenerowany typ C++ | Uwaga |
|---|---|---|
null | std::optional<T> | Typ wartości null jest nieokreślony, zabezpieczany std::optional<T> (C++17+) |
true / false | bool | Wartości logiczne JSON bezpośrednio mapują się na bool C++ |
42 | int64_t | Liczby całkowite JSON domyślnie mapują się na int64_t (<cstdint>), kompatybilne z long long |
3.14 | double | Liczby zmiennoprzecinkowe JSON domyślnie mapują się na double (podwójna precyzja IEEE 754) |
"hello" | std::string | Ciągi JSON mapują się na std::string (<string>) |
["a","b"] | std::vector<std::string> | Tablice ciągów mapują się na std::vector<std::string> |
[1,2,3] | std::vector<int64_t> | Tablice liczb całkowitych mapują się na std::vector<int64_t> |
[{...},{...}] | std::vector<Item> | Tablice obiektów generują odpowiednią strukturę na podstawie pierwszego elementu, a następnie opakowują std::vector |
[] | std::vector<nlohmann::json> | Pusta tablica nie może wnioskować typu elementu, zabezpieczana nlohmann::json (można również przepisać na std::vector<std::string>) |
{...} zagnieżdżony obiekt | Niezależna struktura/klasa | Zagnieżdżone obiekty generują niezależne struktury, nazewnictwo PascalCase (address → Address) |
Porównanie głównych bibliotek parsowania JSON w ekosystemie C++, wybierz zgodnie z wymaganiami projektu:
| Nazwa biblioteki | Styl API | Wydajność | Odpowiednie scenariusze |
|---|---|---|---|
nlohmann::json | Szablony / STL-like | Średnia | Backendy Web, aplikacje desktopowe, nauczanie; najlepsza kompatybilność z std::vector/std::map |
rapidjson | SAX / DOM | Bardzo wysoka | Transakcje finansowe, silniki gier, usługi o wysokiej przepustowości; obsługuje przyspieszenie SIMD |
Boost.JSON | Boost.Container | Wysoka | Projekty ekosystemu Boost, serwery Web (Beast/Asio) |
cJSON | W stylu C / funkcyjny | Wysoka | Projekty C, systemy wbudowane C++, scenariusze niechcące wprowadzać szablonów C++ |
ArduinoJson | Szablony C++ | Średnia | Arduino, ESP32/ESP8266, MCU systemów wbudowanych |
Przegląd podstawowych typów biblioteki standardowej C++ odpowiadających polom JSON, dla szybkiego odniesienia przez deweloperów:
| Słowo kluczowe JSON | Odpowiednik biblioteki standardowej C++ | Wymagany plik nagłówkowy | Standard C++ |
|---|---|---|---|
| string | std::string | <string> | C++98 |
| integer | int64_t (<cstdint>) | <cstdint> | C++11 |
| number | double | <iostream>/<cmath> | C++98 |
| boolean | bool | <stdbool.h>(C)/wbudowany | C++98 |
| null | std::optional<T> | <optional> | C++17 |
| array | std::vector<T> | <vector> | C++98 |
| array stały | std::array<T, N> | <array> | C++11 |
| object/map | std::map<std::string, T> | <map> | C++98 |
| object haszujący | std::unordered_map<K, T> | <unordered_map> | C++11 |
| string view | std::string_view (nie posiada danych) | <string_view> | C++17 |
| byte/char | std::byte/char | <cstddef> | C++17/C++98 |
Wszystkie operacje tego narzędzia JSON na C++ są całkowicie wykonywane lokalnie w Twojej przeglądarce: parsowanie JSON, generowanie struktur C++ i pobieranie plików są wykonywane po stronie klienta za pomocą JavaScript przeglądarki (Web Worker + quicktype-core), żadne dane JSON, przesłane pliki lub wygenerowany kod nie są wysyłane przez sieć na żaden serwer. Przesyłanie plików używa natywnego API FileReader przeglądarki do bezpośredniego odczytu do pamięci, bez pośrednich usług. Nie używa śledzenia plików Cookie, nie zbiera żadnych danych wejściowych użytkownika ani danych użycia. Po zamknięciu lub odświeżeniu strony wszystkie wejściowe i wyjściowe zawartości są automatycznie usuwane z pamięci. Nadaje się do przetwarzania JSON zawierającego klucze API, tokeny, wrażliwe dane biznesowe.