JSON से C++

C++ कोड

अभी कोई सामग्री नहीं

तैयार

मुफ्त ऑनलाइन JSON से C++ टूल, JSON पेस्ट करके स्वचालित रूप से संकलन योग्य C++ struct/class हेडर कोड जनरेट करें। nlohmann/json या rapidjson के साथ API प्रतिक्रिया डीसीरियलाइज़ेशन के लिए उपयुक्त है। नेस्टेड ऑब्जेक्ट स्वचालित रूप से स्वतंत्र क्लासों में अलग हो जाते हैं, std::vector और std::optional स्वचालित रूप से संभाले जाते हैं। पूरी तरह से ब्राउज़र में काम करता है

JSON से C++ के बारे में: JSON डेटा को संकलन योग्य C++ स्ट्रक्ट में बदलना

JSON से C++ JSON प्रारूप (ऑब्जेक्ट या ऐरे) में डेटा को C++ struct/class प्रकार परिभाषा में बदलने की प्रक्रिया है। C++ एक स्ट्रांग-टाइप सिस्टम प्रोग्रामिंग भाषा है जो बैकएंड सेवाओं, गेम इंजन, एम्बेडेड फर्मवेयर, मात्रात्मक व्यापार, उच्च-प्रदर्शन सेवाओं और डेस्कटॉप क्लाइंट में व्यापक रूप से उपयोग की जाती है। विकास में, अक्सर API दस्तावेज़ या वास्तविक प्रतिक्रियाओं से JSON नमूनों को C++ प्रकारों में बदलने की आवश्यकता होती है। मैन्युअल रूप से स्ट्रक्ट लिखना न केवल दोहराव वाला काम है, बल्कि फ़ील्ड प्रकारों को गलत लिखने की भी संभावना होती है। इस टूल का उद्देश्य इस प्रक्रिया को स्वचालित करना है। Java, Python, JavaScript के विपरीत, C++ में JSON जैसी डायनेमिक स्ट्रक्चर के लिए मूल समर्थन नहीं है, इसलिए 'JSON से C++' लंबे समय से इंजीनियरिंग समुदाय में 'दोहराव वाला लेकिन आवश्यक' कार्य माना जाता रहा है

यह टूल quicktype-core पर आधारित ब्राउज़र में लोकल काम करता है, CPP रेंडरर और just-types रेंडर विकल्प का उपयोग करके C++ के लिए स्ट्रक्ट कोड जनरेट करता है जो std::string/std::vector<T>/std::optional<T> का संदर्भ लेता है। जनरेट किया गया कोड मानक हेडर-ओनली C++ कोड है, जो किसी भी तृतीय-पक्ष JSON पार्सिंग लाइब्रेरी पर निर्भर नहीं करता है, किसी भी C++17/C++20 प्रोजेक्ट में सीधे #include किया जा सकता है। nlohmann::json या rapidjson पार्सर के साथ उपयोग करके API प्रतिक्रियाओं को तेज़ी से डीसीरियलाइज़ किया जा सकता है। संपूर्ण रेंडरिंग प्रक्रिया Web Worker के माध्यम से ब्राउज़र में एसिंक्रोनस रूप से होती है, मुख्य थ्रेड सुचारू रूप से प्रतिक्रिया देती रहती है

प्रकार अनुमान JSON से C++ का मूल है। टूल JSON के मूल प्रकारों को C++ मानक प्रकारों में मैप करेगा: स्ट्रिंग std::string में, पूर्णांक int64_t में (long long के साथ संगत, क्रॉस-प्लेटफॉर्म long आकार अंतर से बचता है), फ्लोटिंग पॉइंट double में, बूलियन bool में, ऐरे std::vector<T> में, नेस्टेड ऑब्जेक्ट स्वतंत्र स्ट्रक्ट/क्लास में, null मान std::optional<T> में। नेस्टेड ऑब्जेक्टों के लिए, टूल स्वचालित रूप से प्रत्येक स्तर के लिए एक नया क्लास जनरेट करेगा और PascalCase के अनुसार नाम देगा, उदाहरण के लिए address फ़ील्ड Address स्ट्रक्ट जनरेट करती है, items ऐरे में ऑब्जेक्ट Item स्ट्रक्ट जनरेट करता है। समान नेस्टेड JSON स्तर केवल एक बार जनरेट किए जाएंगे, कोई डुप्लिकेट परिभाषा नहीं

कुछ ऑनलाइन टूलों के विपरीत जिन्हें प्रोसेसिंग के लिए JSON को सर्वर पर अपलोड करने की आवश्यकता होती है, इस टूल की सभी गणनाएं ब्राउज़र में पूरी होती हैं। quicktype-core Web Worker के माध्यम से लोड और निष्पादित किया जाता है, JSON पार्सिंग, प्रकार अनुमान, C++ कोड जनरेशन और फ़ाइल डाउनलोड सभी लोकल रूप से पूरे होते हैं, किसी भी सर्वर पर डेटा नहीं भेजा जाता। यह API कुंजियों, उपयोगकर्ता गोपनीयता फ़ील्ड या अप्रकाशित व्यावसायिक स्ट्रक्चर वाले JSON के लिए विशेष रूप से महत्वपूर्ण है। पेज बंद करने के बाद डेटा मेमोरी से साफ हो जाता है। कॉर्पोरेट नेटवर्क वातावरण, आंतरिक अनुपालन आवश्यकताएं या ऑफ़लाइन विकास परिदृश्य चाहे जो भी हों, यह टूल कमांड-लाइन quicktype टूल के बराबर विश्वसनीयता प्रदान कर सकता है

जनरेट किया गया कोड आमतौर पर JSON पार्सर के साथ उपयोग करने की आवश्यकता होती है, दो मुख्य विकल्प हैं: ① nlohmann::json (अनुशंसित, एकल-हेडर शामिल, टेम्पलेट सीरियलाइज़ेशन इंटरफ़ेस का उपयोग करने में आसान, nlohmann::json j = nlohmann::json::parse(str); User u = j.get<User>(); जैसा लिखें); ② rapidjson (SAX/DOM शैली पार्सिंग, उच्च प्रदर्शन, वित्त, गेम जैसे चरम परिदृश्यों के लिए उपयुक्त, GetObject के साथ स्वयं फ़ील्ड निष्कर्षण की आवश्यकता)। एम्बेडेड सिस्टम के लिए ArduinoJson (सीमित संसाधन) या cJSON (C-शैली इंटरफ़ेस) का भी उपयोग किया जा सकता है। इस टूल का कोड सभी मुख्य C++ JSON लाइब्रेरियों के साथ संगत है, किसी विशेष पारिस्थितिकी तंत्र से बंधा नहीं

यह ध्यान दिया जाना चाहिए कि स्वचालित रूप से जनरेट किया गया कोड प्रारंभिक बिंदु है, अंत नहीं। टूल JSON नमूनों के आधार पर प्रकारों का अनुमान लगाता है, यह व्यावसायिक रूप से सही प्रकार (जैसे URL, ईमेल, ID जैसे सिमेंटिक प्रकार समान रूप से std::string का अनुमान लगाए जाते हैं) का निर्धारण नहीं कर सकता। snake_case JSON फ़ील्ड के लिए, C++ स्ट्रक्ट फ़ील्ड मूल रूप बनाए रखते हुए जनरेट किए जाएंगे। आपको मैपिंग संबंध घोषित करने के लिए स्वयं NLOHMANN_DEFINE_TYPE_INTRUSIVE या NLOHMANN_JSON_FROM/NLOHMANN_JSON_TO जोड़ने की आवश्यकता हो सकती है। जनरेट किए गए परिणाम को पहले ड्राफ्ट के रूप में लेने की अनुशंसा की जाती है, फिर प्रोजेक्ट विनिर्देशों के अनुसार फ़ील्ड नाम, प्रकार और सीरियलाइज़ेशन एनोटेशन समायोजित करें। यह 'AI पहला ड्राफ्ट लिखता है + इंजीनियर समीक्षा करता है' वर्कफ़्लो कई C++ टीमों की वास्तविक कार्य लय भी है

क्रॉस-टीम सहयोग परिदृश्यों में, JSON से C++ डेटा मॉडल एकीकरण का सेतु भी है। फ्रंटएंड JSON से TypeScript का उपयोग करता है, बैकएंड JSON से Java/Go/Rust का उपयोग करता है, एम्बेडेड सिस्टम और उच्च-प्रदर्शन सेवाएं JSON से C++ का उपयोग करती हैं। चारों पक्ष एक ही JSON नमूने से अपने स्वयं के प्रकार परिभाषाएं बनाते हैं, जो फ़ील्ड स्थिरता को अधिकतम रूप से सुनिश्चित करता है। यह टूल इस वर्कफ़्लो का 'C++ पक्ष' है, साइट के अन्य टूलों के साथ JSON से TypeScript/Java/Rust/Go/Python रूपांतरण के लिए एक साथ उपयोग किया जा सकता है

एक वाक्य में सारांश: यदि आपका कोड प्रदर्शन-संवेदी, स्ट्रांग-टाइप, समृद्ध पारिस्थितिकी तंत्र वाले C++ प्रोजेक्ट में चलता है, और आपको JSON जैसे डायनेमिक डेटा को तेज़ी से स्ट्रांग-टाइप दुनिया से जोड़ने की आवश्यकता है, तो यह टूल JSON नमूनों को C++ स्ट्रक्ट में संकलित करने के लिए सीधा प्रारंभिक बिंदु है

उपयोग के मामले

REST API कनेक्शन: बैकएंड से लौटाई गई JSON प्रतिक्रिया को C++ स्ट्रक्ट में बदलें, प्रकार-सुरक्षित HTTP अनुरोध डीसीरियलाइज़ेशन के लिए nlohmann::json/cpr के साथ संयोजित करें
माइक्रोसर्विस इंटरफ़ेस परिभाषा: gRPC/HTTP सेवा अनुरोध निकाय JSON नमूने को C++ प्रकारों में बदलें, सर्वर-साइड मॉडल परिभाषाएं एकत्र करें
एम्बेडेड सिस्टम और IoT: डिवाइस द्वारा रिपोर्ट किए गए सेंसर JSON डेटा को C++ स्ट्रक्ट में बदलें, MQTT/HTTP संदेश पार्स करने के लिए ArduinoJson या ESP-IDF JSON Parser के साथ संयोजित करें
गेम डेवलपमेंट: लेवल कॉन्फ़िगरेशन JSON, चरित्र गुणों को C++ स्ट्रक्ट में बदलें, Unreal Engine या Cocos2d-x जैसे इंजनों के लिए .json डेटा फ़ाइलें पढ़ना आसान बनाएं
उच्च-आवृत्ति वित्तीय व्यापार: एक्सचेंज JSON इंटरफ़ेस प्रतिक्रिया (जैसे OKX/Binance/Xueqiu बाजार डेटा) को C++ स्ट्रक्ट में बदलें, नैनोसेकंड-स्तरीय पार्सिंग के लिए rapidjson के साथ संयोजित करें
Qt C++ क्लाइंट: सर्वर कॉन्फ़िगरेशन JSON को C++ स्ट्रक्ट में बदलें, GUI डेटा लोड करने के लिए QJsonObject/QJsonDocument के साथ संयोजित करें
Boost.JSON/Boost.Beast: HTTP सेवा JSON प्रतिक्रिया को C++ स्ट्रक्ट में बदलें, वेब बैकएंड लिखने के लिए डीसीरियलाइज़ेशन के लिए Boost.JSON के साथ संयोजित करें
एम्बेडेड RTOS: FreeRTOS/Zephyr सिस्टम कॉन्फ़िगरेशन JSON को C++ स्ट्रक्ट में बदलें, फर्मवेयर पैरामीटर पढ़ने के लिए cJSON के साथ संयोजित करें
एल्गोरिदम/मात्रात्मक व्यापार: बैकटेस्टिंग सिस्टम कॉन्फ़िगरेशन JSON को C++ स्ट्रक्ट में बदलें, A/B प्रयोग कॉन्फ़िगरेशन प्रबंधन और संस्करण ट्रैकिंग आसान बनाएं
डेटाबेस माइग्रेशन: MongoDB/PostgreSQL से निर्यात किए गए JSON दस्तावेज़ों को C++ मॉडल में बदलें, cpp-httplib/libpqxx इकाई फ़ील्ड संदर्भ के रूप में उपयोग करें
ऑडियो/वीडियो/मल्टीमीडिया: FFmpeg/GStreamer कॉन्फ़िगरेशन JSON को C++ स्ट्रक्ट में बदलें, मीडिया पाइपलाइन पैरामीटर पढ़ना आसान बनाएं
सिमुलेशन और मॉडलिंग: सिमुलेशन सिस्टम इनपुट कॉन्फ़िगरेशन JSON को C++ स्ट्रक्ट में बदलें, विभिन्न उप-मॉडलों के इनपुट डेटा प्रारूप एकत्र करें
परीक्षण डेटा निर्माण: बैकएंड से लौटाए गए वास्तविक JSON फिक्स्चर को C++ प्रकारों में बदलें, Google Test/Catch2 यूनिट परीक्षणों में संरचनात्मक दावे करें
संरचित लॉग पार्सिंग: ELK/Loki द्वारा कैप्चर किए गए JSON लॉग को C++ प्रकारों में बदलें, फ़िल्टरिंग नियम और अलर्ट बनाना आसान बनाएं
कॉन्फ़िगरेशन केंद्र माइग्रेशन: Apollo/Nacos/Consul कॉन्फ़िगरेशन JSON को C++ प्रकारों में बदलें, सर्वर-साइड हॉट कॉन्फ़िगरेशन लोडिंग के लिए उपयोग करें
क्रॉस-भाषा सहयोग: C++ बैकएंड को TypeScript/Java फ्रंटएंड से कनेक्ट करें, एक ही JSON क्रमशः C++ स्ट्रक्ट और TS इंटरफ़ेस/Java POJO में परिवर्तित किया जाएगा ताकि दोनों पक्षों की स्थिरता बनी रहे
शिक्षण और प्रशिक्षण: C++ पाठ्यक्रमों में JSON नमूनों को स्ट्रक्ट में बदलें, nlohmann::json डीसीरियलाइज़ेशन प्रक्रिया और टेम्पलेट मेटाप्रोग्रामिंग अवधारणाओं का प्रदर्शन करें
फ़ील्ड नाम रूपांतरण: snake_case प्रारूप में API JSON प्रतिक्रिया को C++ स्ट्रक्ट में बदलने के बाद, फ़ील्ड मैपिंग करने के लिए स्वयं NLOHMANN_DEFINE_TYPE_INTRUSIVE जोड़ें

उपयोग कैसे करें

बाईं ओर के संपादक में JSON सामग्री पेस्ट करें (JSON ऑब्जेक्ट की अनुशंसा की जाती है), या .json/.txt फ़ाइल चुनने के लिए अपलोड बटन पर क्लिक करें
टूल Web Worker के माध्यम से quicktype-core का उपयोग करके 400ms के भीतर स्वचालित रूप से रूपांतरण पूरा करता है, std::string/std::vector<T>/नेस्टेड क्लासों वाला C++ हेडर कोड दाईं ओर प्रदर्शित होता है
यदि JSON प्रारूप अमान्य है तो लाल संकेत दिखाई देगा, सामान्य समस्याओं जैसे ट्रेलिंग कॉमा, सिंगल कोट्स को स्वचालित रूप से ठीक करने के लिए 'JSON मरम्मत करें' बटन पर क्लिक करें फिर पुनः प्रयास करें
जांचें कि जनरेट किए गए स्ट्रक्ट/क्लास के नाम और फ़ील्ड प्रकार अपेक्षित हैं या नहीं। समायोजन की आवश्यकता होने पर मूल JSON में कुंजी नाम संशोधित करें फिर पुनः रूपांतरित करें
'कॉपी' पर क्लिक करके कोड को IDE में .h/.hpp फ़ाइल में पेस्ट करें, वास्तविक API प्रतिक्रिया डीसीरियलाइज़ करने के लिए nlohmann::json या rapidjson के साथ उपयोग करें; या model.h/model.hpp के रूप में सहेजने के लिए 'डाउनलोड' पर क्लिक करें

विशेषताएं

लोकल ब्राउज़र रूपांतरण: सभी JSON पार्सिंग और C++ कोड जनरेशन Web Worker + quicktype-core के माध्यम से ब्राउज़र में पूरा होता है, मूल डेटा किसी भी सर्वर पर नहीं भेजा जाता
nlohmann::json शैली आउटपुट: स्वचालित रूप से std::string/std::vector<T>/double/int64_t/bool जैसे STL प्रकार के स्ट्रक्ट जनरेट करता है, nlohmann::json डीसीरियलाइज़ेशन आदतों के अनुरूप, सीधे पार्स करने के लिए <nlohmann/json.hpp> शामिल किया जा सकता है
rapidjson के साथ संगत: जनरेट किए गए शुद्ध C++ स्ट्रक्ट किसी भी तृतीय-पक्ष लाइब्रेरी पर निर्भर नहीं करते हैं, उच्च प्रदर्शन पार्सिंग परिदृश्यों में rapidjson Document/GenericValue के साथ उपयोग किए जा सकते हैं
स्वचालित प्रकार अनुमान: JSON स्ट्रिंग std::string में मैप होती है, पूर्णांक int64_t/long long में, फ्लोटिंग पॉइंट double में, बूलियन bool में, ऐरे std::vector<T> में, नेस्टेड ऑब्जेक्ट स्वतंत्र क्लास/स्ट्रक्ट में
स्वचालित नेस्टेड ऑब्जेक्ट अपघटन: नेस्टेड JSON स्वचालित रूप से स्वतंत्र क्लास/स्ट्रक्ट (PascalCase नामकरण) जनरेट करता है, समान प्रकार की परिभाषाओं की पुनरावृत्ति से बचता है
स्वचालित std::vector और std::optional प्रबंधन: JSON ऐरे स्वचालित रूप से std::vector<T> में परिवर्तित होते हैं, null हो सकने वाले फ़ील्ड std::optional<T> के रूप में स्वीकार किए जाते हैं, आधुनिक C++17/C++20 प्रथाओं के अनुरूप
400ms डीबाउंस स्वचालित रूपांतरण: JSON पेस्ट करने के बाद स्वचालित रूप से रूपांतरण ट्रिगर होता है, C++ हेडर कोड दाईं ओर रीयल-टाइम में पूर्वावलोकन होता है, अनावश्यक प्रतीक्षा और क्लिक कम करता है
एक क्लिक में JSON त्रुटि मरम्मत: सामान्य प्रारूप त्रुटियों जैसे ट्रेलिंग कॉमा, सिंगल कोट्स, लापता कोट्स को स्वचालित रूप से ठीक करता है, सफल मरम्मत के बाद कोड जनरेशन जारी रखता है
सिंटैक्स हाइलाइटिंग + एक क्लिक कॉपी: दाईं ओर CodeMirror क्षेत्र C++ सिंटैक्स हाइलाइटिंग प्रदर्शित करता है, एक क्लिक में पूरा हेडर कॉपी करें या .h/.hpp फ़ाइल के रूप में डाउनलोड करें, सीधे प्रोजेक्ट में डालें
localStorage इनपुट इतिहास + प्रतिक्रियाशील कॉलम: स्वचालित रूप से नवीनतम इनपुट सहेजता है, आकस्मिक रीफ्रेश या पेज बंद करने के बाद जल्दी से पुनर्स्थापित कर सकता है। बाईं ओर JSON पेस्ट करें, दाईं ओर C++ कोड देखें, पैनल चौड़ाई समायोजित करने के लिए ड्रैग का समर्थन, बड़ी स्क्रीन और मोबाइल डिवाइसों के अनुकूल
हेडर-ओनली, नो-डिपेंडेंसी आउटपुट: जनरेट किया गया .h/.hpp हेडर-ओनली रूप में है, किसी भी मानक C++ प्रोजेक्ट में एकल फ़ाइल में शामिल किया जा सकता है, बिना किसी अतिरिक्त बिल्ड कॉन्फ़िगरेशन के nlohmann::json/rapidjson/Boost.JSON के साथ उपयोग किया जा सकता है
बिल्ट-इन snake_case से camelCase रूपांतरण: स्वचालित रूप से JSON में snake_case फ़ील्ड को C++ अनुशंसित camelCase फ़ील्ड नामों में बदल सकता है, snake_case सीरियलाइज़ेशन मैपिंग बनाए रखने के लिए NLOHMANN_DEFINE_TYPE_INTRUSIVE के साथ काम करता है

कोड उदाहरण

C++: इस टूल द्वारा जनरेट किए गए स्ट्रक्ट को nlohmann/json के साथ डीसीरियलाइज़ करें

cpp

जनरेट किए गए User स्ट्रक्ट को .hpp में रखें, nlohmann::json के साथ डीसीरियलाइज़ेशन करें (आधुनिक C++17/20 प्रोजेक्टों के लिए अनुशंसित)

// 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) इस टूल द्वारा जनरेट किए गए स्ट्रक्ट में प्रकार-सुरक्षित डीसीरियलाइज़ेशन
    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
 * एकल-फ़ाइल शामिल:
 *   json.hpp को सीधे https://github.com/nlohmann/json/releases रिलीज से डाउनलोड करें
 */

C++: इस टूल द्वारा जनरेट किए गए स्ट्रक्ट को rapidjson के साथ पार्स करें

cpp

rapidjson कस्टम स्ट्रक्ट में स्वचालित डीसीरियलाइज़ेशन का समर्थन नहीं करता, GetObject के साथ स्वयं फ़ील्ड निष्कर्षण की आवश्यकता होती है, वित्त/गेम जैसे उच्च-प्रदर्शन परिदृश्यों के लिए उपयुक्त

#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) इस टूल द्वारा जनरेट किया गया स्ट्रक्ट बनाएं और स्वयं भरें
    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) भरे हुए स्ट्रक्ट का उपयोग करें
    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 निर्देशों का उपयोग करके त्वरण प्राप्त होता है
 */

C++: NLOHMANN_DEFINE_TYPE_INTRUSIVE के साथ snake_case फ़ील्ड मैपिंग संभालें

cpp

जब JSON फ़ील्ड snake_case प्रारूप में हों और आप चाहते हैं कि C++ सदस्य camelCase/PascalCase का उपयोग करें, तो nlohmann/json मैक्रो के साथ मैपिंग घोषित करें

#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 का उपयोग करें
// नोट: सार्वजनिक क्षेत्र में रखा जाना चाहिए
// 
// 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) सार्वजनिक क्षेत्र में रखा जाना चाहिए;
 *   ② गैर-आक्रामक मैक्रो (NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE) क्लास के बाहर परिभाषित किया गया है;
 *   ③ फ़ील्ड क्रम मैक्रो पैरामीटर क्रम से सख्ती से मेल खाना चाहिए;
 *   ④ दिनांक फ़ील्ड nlohmann::json के कस्टम adl_serializer के माध्यम से ISO 8601 प्रारूप में प्रोसेस किए जा सकते हैं
 */

Best Practices

अधिकांश टीमों को पहले nlohmann::json का उपयोग करने की सिफारिश की जाती है, क्योंकि API STL-शैली की है, डीसीरियलाइज़ेशन j.get<User>() के साथ एक पंक्ति में पूरा होता है, पठनीयता बहुत अच्छी है। केवल जब आप प्रदर्शन बॉटलनेक का सामना करें (जैसे प्रति सेकंड लाखों JSON फ़ील्ड पार्स करना) तो rapidjson पर स्विच करें। इस टूल द्वारा जनरेट किए गए स्ट्रक्ट दोनों के साथ काम कर सकते हैं

nlohmann/json रिपॉजिटरी rapidjson रिपॉजिटरी

include(FetchContent) + FetchContent_Declare(nlohmann_json URL ...) का उपयोग CMaker में nlohmann/json को शामिल करने का सबसे स्वच्छ तरीका है, अग्रिम रूप से vcpkg स्थापित करने की आवश्यकता नहीं; यदि FetchContent कॉन्फ़िगर नहीं करना चाहते हैं तो vcpkg install nlohmann-json का उपयोग कर सकते हैं या सीधे एकल json.hpp फ़ाइल डाउनलोड करके शामिल करें

CMake FetchContent आधिकारिक दस्तावेज़ीकरण

टूल डिफ़ॉल्ट रूप से JSON के मूल फ़ील्ड नाम (snake_case) को बनाए रखता है। यदि आप चाहते हैं कि C++ सदस्य camelCase या PascalCase हों, तो JSON कुंजियों और C++ सदस्यों के बीच स्पष्ट रूप से मैप करने के लिए क्लास के भीतर NLOHMANN_DEFINE_TYPE_INTRUSIVE(UserProfile, id, userName, ...) जोड़ना होगा, अन्यथा डीसीरियलाइज़ेशन विफल हो जाएगा

NLOHMANN_DEFINE_TYPE_INTRUSIVE दस्तावेज़ीकरण

C++17+ सीधे std::optional<T> का उपयोग करें; C++11/14 प्रोजेक्ट boost::optional<T> (#include <boost/optional.hpp>) से प्रतिस्थापित करें; C-शैली प्रोजेक्ट null मान दर्शाने के लिए cJSON + सेंटिनल फ़ील्ड (-1, खाली स्ट्रिंग) का उपयोग करें। ध्यान दें कि std::optional और boost::optional के इंटरफ़ेस में मामूली अंतर हैं (has_value() बनाम is_initialized())

cppreference std::optional

Arduino Uno/ESP8266 जैसे बहुत कम RAM वाले डिवाइसों पर, std::vector और std::string अक्सर OOM का कारण बनते हैं। इसके बजाय ArduinoJson 6.x + StaticJsonDocument<क्षमता> का उपयोग करके बफर सीमित करें, std::vector<T> को निश्चित आकार के std::array<T, N> से बदलें, std::string को const char* + लंबाई से बदलें

ArduinoJson दस्तावेज़ीकरण

इस टूल की सभी पार्सिंग, कोड जनरेशन और फ़ाइल डाउनलोड ब्राउज़र में लोकल Web Worker के माध्यम से पूरे होते हैं, मूल JSON किसी भी सर्वर पर नहीं भेजा जाता। फिर भी अनुशंसा की जाती है: ① आंतरिक व्यावसायिक मॉडल को पहले असंवेदनशील बनाएं (टोकन/फ़ोन नंबर आदि हटा दें); ② पेज बंद करने से मेमोरी साफ हो जाती है; ③ बड़ी कंपनी अनुपालन परिदृश्यों में IDE में लोकल कमांड-लाइन quicktype के साथ ग्राहक डेटा वाले JSON को प्रोसेस करने की अनुशंसा की जाती है

6 स्तर से अधिक नेस्टिंग वाले JSON को स्रोत पक्ष में पुनर्गठित करने की सिफारिश की जाती है, या इस टूल द्वारा जनरेट करने के बाद स्वयं गहरे नेस्टेड स्ट्रक्ट को मध्यवर्ती स्ट्रक्टों में विभाजित करें ताकि पठनीयता और संकलन गति में सुधार हो। गहरी नेस्टिंग टेम्पलेट इंस्टेंटिएशन गहराई को बहुत गहरा बना देगी, कुछ पुराने कंपाइलर (GCC 6 से नीचे) 'टेम्पलेट इंस्टेंटिएशन गहराई पार हो गई' त्रुटि देंगे

इस टूल द्वारा जनरेट किया गया कोड अनिवार्य रूप से C++ है (std::optional/टेम्पलेट जैसी C++ सुविधाओं का उपयोग करता है), प्रोजेक्ट में C हेडर .h से अलग करने के लिए .hpp एक्सटेंशन का उपयोग करने की सिफारिश की जाती है, जिसका अर्थ है 'C++ हेडर'। CMake में: set_target_properties(target PROPERTIES CXX_EXTENSIONS ON); CMake भी .h बनाम .hpp के आधार पर स्वचालित रूप से पहचान सकता है कि gcc या g++ के साथ संकलन करना है, हेडर-ओनली टेम्पलेट पुनः इंस्टेंटिएट नहीं होने की समस्या को अधिकतम रूप से कम करता है

GCC फ़ाइल एक्सटेंशन विनिर्देश CMake फ़ाइल प्रकार पहचान

सामान्य प्रश्न

JSON को C++ स्ट्रक्ट/क्लास डेफिनिशन में कैसे बदलें

बाईं ओर के संपादक में JSON सामग्री पेस्ट करें (ड्रैग एंड ड्रॉप या क्लिक करके .json/.txt फ़ाइल अपलोड करने का भी समर्थन करता है)। टूल स्वचालित रूप से 400ms के भीतर ब्राउज़र में quicktype-core को कॉल करके C++ हेडर कोड जनरेट करेगा; दाईं ओर CodeMirror क्षेत्र std::string/std::vector<T>/नेस्टेड क्लासों वाला स्ट्रक्ट कोड प्रदर्शित करेगा। यदि JSON प्रारूप अमान्य है, तो 'JSON मरम्मत करें' बटन पर क्लिक करके स्वचालित रूप से मरम्मत करें फिर पुनः रूपांतरित करें

जनरेट किए गए C++ कोड में कौन सी हेडर फ़ाइलें शामिल करनी होंगी

टूल केवल C++ मानक लाइब्रेरी (<string>, <vector>, <optional>, <cstdint>) पर निर्भर हेडर-ओनली स्ट्रक्ट कोड जनरेट करता है। nlohmann/json के साथ पार्स करते समय अतिरिक्त #include <nlohmann/json.hpp> की आवश्यकता होती है; rapidjson के साथ पार्स करते समय #include "rapidjson/document.h" की आवश्यकता होती है। आवश्यकतानुसार अन्य मानक हेडर टूल द्वारा घोषित किए जाएंगे

कौन से JSON डेटा स्ट्रक्चर समर्थित हैं

सभी वैध JSON स्ट्रक्चर समर्थित हैं: मूल प्रकार (null, boolean, number, string), ऐरे (एक-आयामी या बहु-आयामी), नेस्टेड ऑब्जेक्ट (किसी भी गहराई तक)। JSON ऑब्जेक्ट रूट स्ट्रक्ट/क्लास जनरेट करेंगे, JSON ऐरे ऊपरी स्ट्रक्ट के फ़ील्ड में std::vector<T> के रूप में दिखाई देंगे। JavaScript ऑब्जेक्ट लिटरल, फ़ंक्शन, Symbol, undefined और अन्य गैर-JSON मान समर्थित नहीं हैं

JSON फ़ील्ड प्रकार C++ प्रकारों में कैसे मैप होते हैं

स्ट्रिंग std::string में मैप होती है; पूर्णांक int64_t (पुराने कोड संगतता के लिए अक्सर long long); फ्लोटिंग पॉइंट double; बूलियन bool; ऐरे std::vector<T>; नेस्टेड ऑब्जेक्ट स्वतंत्र स्ट्रक्ट/क्लास; null मान std::optional<T> (nlohmann::json द्वारा समर्थित हो सकता है)। विस्तृत मैपिंग नियमों के लिए पृष्ठ के नीचे 'JSON प्रकार से C++ प्रकार मैपिंग संदर्भ तालिका' देखें

null मान किस प्रकार को जनरेट करते हैं

JSON में null मान std::optional<T> (C++17 से उपलब्ध) जनरेट करते हैं, जो दर्शाता है कि फ़ील्ड अनुपस्थित या अनिश्चित प्रकार का हो सकता है। यदि आप फ़ील्ड के वास्तविक प्रकार को पहले से जानते हैं, तो आप मूल JSON में एक नमूना मान प्रदान कर सकते हैं (उदाहरण के लिए "field": "" std::string का अनुमान लगाएगा) फिर व्यावसायिक आवश्यकताओं के अनुसार निर्माण के बाद std::optional<std::string> जैसे अधिक सटीक प्रकार में बदलें

क्या ऐरे स्वचालित रूप से std::vector में बदल जाते हैं

हाँ, JSON ऐरे समान रूप से C++ टेम्पलेट कंटेनर std::vector<T> में परिवर्तित होते हैं, तत्व प्रकार स्वचालित रूप से ऐरे के पहले तत्व के आधार पर अनुमानित किया जाता है। उदाहरण के लिए ["a","b"] std::vector<std::string> बनाता है, [1,2,3] std::vector<int64_t> बनाता है, [{...},{...}] std::vector<Item> बनाता है (जहां Item नेस्टेड ऑब्जेक्ट से जनरेट किया गया स्वतंत्र स्ट्रक्ट है)

नेस्टेड ऑब्जेक्ट कैसे संभाले जाते हैं

प्रत्येक नेस्टेड ऑब्जेक्ट एक स्वतंत्र स्ट्रक्ट/क्लास जनरेट करेगा, नामकरण नियम फ़ील्ड नाम से PascalCase है (उदाहरण के लिए address फ़ील्ड Address स्ट्रक्ट जनरेट करती है, items ऐरे में ऑब्जेक्ट Item स्ट्रक्ट जनरेट करता है)। रूट स्ट्रक्ट में, नेस्टेड ऑब्जेक्ट std::optional<Address> या Address प्रकार के सदस्यों द्वारा संदर्भित किए जाएंगे। समान स्ट्रक्चर वाले ऑब्जेक्ट समान प्रकार का पुन: उपयोग करेंगे, डुप्लिकेट परिभाषाओं से बचेंगे

क्या जनरेट किया गया कोड nlohmann/json के साथ डीसीरियलाइज़ेशन के लिए उपयोग किया जा सकता है

हाँ, सामान्य उपयोग: nlohmann::json j; j["root"] = nlohmann::json::parse(raw_json); User u = j.get<User>(); शर्त यह है कि प्रोजेक्ट ने nlohmann/json सिंगल-हेडर संदर्भ जोड़ा है (सीधे <nlohmann/json.hpp> शामिल करें) और इस टूल द्वारा जनरेट किया गया User स्ट्रक्ट परिभाषित किया है

क्या जनरेट किया गया कोड rapidjson के साथ डीसीरियलाइज़ेशन के लिए उपयोग किया जा सकता है

हाँ, rapidjson को आपको GetObject प्रकार के फ़ील्ड निष्कर्षण कोड स्वयं लिखने की आवश्यकता होती है। सामान्य मार्ग: rapidjson::Document doc; doc.Parse(raw_json); const auto& obj = doc["root"]; std::string id = obj["id"].GetString(); चूंकि rapidjson टेम्पलेट के माध्यम से स्वचालित डीसीरियलाइज़ेशन का समर्थन नहीं करता है, जनरेट किए गए स्ट्रक्ट केवल डेटा मॉडल संदर्भ के रूप में कार्य करते हैं

snake_case JSON फ़ील्ड कैसे संभाले जाते हैं

टूल डिफ़ॉल्ट रूप से JSON के मूल फ़ील्ड नाम (जैसे user_name) को बनाए रखते हुए C++ फ़ील्ड जनरेट करेगा। यदि आप चाहते हैं कि C++ सदस्य camelCase (userName) या PascalCase (UserName) का उपयोग करें, तो आप जनरेशन के बाद स्वयं संशोधित कर सकते हैं और मैपिंग निर्दिष्ट करने के लिए NLOHMANN मैक्रोज़ (NLOHMANN_DEFINE_TYPE_INTRUSIVE/NLOHMANN_JSON_FROM/NLOHMANN_JSON_TO) जोड़ सकते हैं

क्या जनरेट की गई हेडर फ़ाइलें सीधे Qt/Unreal/Boost प्रोजेक्ट में डाली जा सकती हैं

हाँ, इस टूल द्वारा जनरेट किया गया कोड मानक हेडर-ओनली C++ कोड है, जो किसी विशिष्ट फ्रेमवर्क पर निर्भर नहीं करता है। Qt QJsonObject के साथ पार्स करते समय स्ट्रक्ट को डेटा मॉडल (Q_GADGET चिह्नित सदस्य) के रूप में उपयोग करें; Unreal Engine के साथ उपयोग करते समय FJsonObjectConverter::JsonObjectStringToUStruct के साथ संयोजित करें; Boost.JSON के साथ उपयोग करते समय JSON को boost::json::object में पार्स करें फिर फ़ील्ड-दर-फ़ील्ड निष्कर्षण करें

क्या डेटा सर्वर पर अपलोड किया जाएगा? क्या यह गोपनीयता के लिए सुरक्षित है

पूरी तरह से ब्राउज़र में काम करता है। JSON पार्सिंग, C++ कोड जनरेशन और फ़ाइल डाउनलोड सभी ब्राउज़र में JavaScript (Web Worker + quicktype-core) के माध्यम से पूरे होते हैं। इनपुट JSON डेटा और जनरेट किया गया C++ कोड किसी भी सर्वर पर नहीं भेजा जाएगा, क्लाउड में सहेजा या कैश नहीं किया जाएगा। API कुंजियों, टोकन, अप्रकाशित व्यावसायिक फ़ील्ड वाले संवेदनशील JSON सुरक्षित रूप से उपयोग किए जा सकते हैं। पेज बंद करने पर डेटा साफ हो जाता है

क्या पंजीकरण या लॉगिन आवश्यक है

आवश्यक नहीं। पूरी तरह से मुफ्त टूल, किसी पंजीकरण, लॉगिन या अनुमति की आवश्यकता नहीं। पेज खोलें और सीधे उपयोग करें। सभी कार्य ब्राउज़र में बिना कॉल सीमा या फ़ाइल आकार प्रतिबंध के उपलब्ध हैं (ब्राउज़र मेमोरी द्वारा सीमित)

JSON प्रारूप त्रुटि होने पर क्या करें

टूल स्वचालित रूप से JSON की वैधता की जांच करेगा। यदि कोई त्रुटि है तो दाईं ओर एक लाल त्रुटि संदेश प्रदर्शित होगा और 'JSON मरम्मत करें' बटन होगा। क्लिक करने के बाद यह सामान्य त्रुटियों को स्वचालित रूप से ठीक कर सकता है: अंतिम अतिरिक्त कॉमा, एकल कोट्स को दोहरे कोट्स से बदलना, बिना कोट्स वाली कुंजियों के लिए कोट्स भरना, टिप्पणियां हटाना आदि। सफल मरम्मत के बाद C++ कोड जनरेशन जारी रहेगा

यह टूल JSON से Java / JSON से Rust से कैसे अलग है

तीनों JSON को लक्षित भाषा में प्रकार की परिभाषा में परिवर्तित करते हैं, लेकिन आउटपुट रूप अलग है: JSON से C++ हेडर-ओनली स्ट्रक्ट/क्लास जनरेट करता है, जिसे अतिरिक्त डीसीरियलाइज़ेशन कोड लिखने के लिए nlohmann/json या rapidjson की आवश्यकता होती है; JSON से Java पूर्ण POJO क्लास (getter/setter के साथ) जनरेट करता है, जो सीधे संकलन और चल सकती है; JSON से Rust Serde derive वाला स्ट्रक्ट जनरेट करता है, जो serde_json के साथ सीधे डीसीरियलाइज़ किया जा सकता है। चयन आपके तकनीकी स्टैक पर निर्भर करता है

समस्या निवारण

'कृपया JSON डेटा दर्ज करें' संकेत या दाईं ओर खाली

बाईं ओर इनपुट बॉक्स खाली है या केवल रिक्त स्थान हैं। सुनिश्चित करें कि आपने वैध JSON सामग्री पेस्ट की है, या .json/.txt फ़ाइल चुनने के लिए अपलोड बटन पर क्लिक करें। आप बिल्ट-इन नमूना लोड करने के लिए नमूना बटन पर भी क्लिक कर सकते हैं (नेस्टेड address/tags फ़ील्ड के साथ)

JSON पार्सिंग विफल संकेत

सामान्य कारण: अंत में अतिरिक्त कॉमा, दोहरे कोट्स के बजाय सिंगल कोट्स, बिना कोट्स वाली कुंजियां, JavaScript टिप्पणियां। कुछ त्रुटियों को स्वचालित रूप से ठीक करने के लिए 'JSON मरम्मत करें' बटन पर क्लिक करें; यदि अभी भी सफल नहीं होता है तो JSON फॉर्मेटर टूल से जांचें

'std::optional घोषित नहीं है' संकलन त्रुटि

प्रोजेक्ट C++17 या उच्चतर मानक का उपयोग नहीं कर रहा है। std::optional C++17 में पेश किया गया था। CMakeLists.txt में CMAKE_CXX_STANDARD को 17 या उच्चतर पर सेट करें (या set(CMAKE_CXX_STANDARD 17) का उपयोग करें); या स्रोत फ़ाइल के शीर्ष पर #include <optional> जोड़ें और कंपाइलर संस्करण की पुष्टि करें

'int64_t घोषित नहीं है' संकलन त्रुटि

टूल <cstdint> से int64_t का उपयोग करता है, GCC 4.5+/Clang 3.0+/MSVC 2015+ की आवश्यकता होती है। जांचें कि स्रोत फ़ाइल के शीर्ष पर #include <cstdint> या #include <stdint.h> है या नहीं, और पुष्टि करें कि CMake की C++ मानक सेटिंग C++11 से >= है

nlohmann::json डीसीरियलाइज़ेशन के दौरान फ़ील्ड गुम हैं

संभावित कारण: ① JSON फ़ील्ड नाम C++ सदस्य नाम से पूरी तरह मेल नहीं खाते (snake_case बनाम camelCase); ② नेस्टेड ऑब्जेक्ट सही तरीके से संभाले नहीं गए; ③ std::optional फ़ील्ड के value() तक पहुंचने से अपवाद फेंका जाता है। समाधान: स्पष्ट रूप से फ़ील्ड मैप करने के लिए NLOHMANN_DEFINE_TYPE_INTRUSIVE मैक्रो जोड़ें, या डिफ़ॉल्ट मान प्रदान करने के लिए j.value("key", default) का उपयोग करें

rapidjson पार्सिंग के दौरान GetString सेगमेंट गलती

rapidjson डिफ़ॉल्ट रूप से फ़ील्ड प्रकार की जांच नहीं करता, GetString केवल तभी सुरक्षित है जब फ़ील्ड वास्तव में मौजूद हो और स्ट्रिंग प्रकार की हो। बेहतर लेखन: if (doc.HasMember("name") && doc["name"].IsString()) { u.name = doc["name"].GetString(); } गैर-मौजूद कुंजियों पर सीधे GetInt/GetString का उपयोग करने से बचें

जनरेट किए गए फ़ील्ड प्रकार पर्याप्त सटीक नहीं हैं (सभी पूर्णांक int64_t हैं)

टूल JSON नमूनों के आधार पर प्रकारों का अनुमान लगाता है, सभी पूर्णांक int64_t हैं, सभी स्ट्रिंग std::string हैं। यदि आपको int32_t, uint64_t, std::chrono::system_clock::time_point जैसे अधिक सटीक प्रकारों की आवश्यकता है, तो जनरेशन के बाद स्वयं फ़ील्ड प्रकार बदलें और सुनिश्चित करें कि चयनित JSON पार्सिंग लाइब्रेरी उस प्रकार के डीसीरियलाइज़ेशन का समर्थन करती है

null फ़ील्ड std::optional<std::string> के बजाय std::optional<nlohmann::json> जनरेट करते हैं

चूंकि JSON null विशिष्ट प्रकार का अनुमान नहीं लगा सकता, टूल सुरक्षित रूप से std::optional<nlohmann::json> के रूप में स्वीकार करता है। यदि आप फ़ील्ड के वास्तविक प्रकार को जानते हैं, तो आप मूल JSON में एक नमूना मान प्रदान कर सकते हैं (उदाहरण के लिए "field": "" std::string का अनुमान लगाएगा) पुनः जनरेट करें फिर स्वयं std::optional<std::string> में बदलें

snake_case JSON फ़ील्ड C++ नामकरण शैली के अनुरूप नहीं हैं

टूल डिफ़ॉल्ट रूप से JSON के मूल फ़ील्ड नाम (जैसे user_name) को बनाए रखते हुए C++ फ़ील्ड जनरेट करता है। यदि आप चाहते हैं कि C++ सदस्य camelCase (userName) का उपयोग करें और साथ ही snake_case JSON को सही तरीके से डीसीरियलाइज़ करें, तो कृपया codeExamples के अनुच्छेद 3 को देखें, NLOHMANN_DEFINE_TYPE_INTRUSIVE/NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE मैक्रो का उपयोग करें

डाउनलोड की गई .hpp फ़ाइल में प्रोजेक्ट में संकलन त्रुटि है

संभावित कारण: ① CMake ने C++17/C++20 मानक सेट नहीं किया है; ② <optional>/<vector> जैसे हेडर गुम हैं; ③ स्ट्रक्ट नाम प्रोजेक्ट में अन्य प्रकारों से टकरा रहा है। समाधान: CMakeLists.txt में set(CMAKE_CXX_STANDARD 17) जोड़ें, स्रोत फ़ाइल के शीर्ष पर उचित हेडर जोड़ें, namespace से लपेटें या टकराने वाले स्ट्रक्ट का नाम बदलें

शब्दकोश

struct / class: मिश्रित डेटा प्रकार परिभाषित करने के लिए C++ में कीवर्ड। यह टूल struct जनरेट करता है, जैसे struct User { int64_t id; std::string name; }। C++ में struct और class लगभग समकक्ष हैं (अंतर डिफ़ॉल्ट पहुंच अधिकार: struct सदस्य डिफ़ॉल्ट रूप से public होते हैं, class सदस्य डिफ़ॉल्ट रूप से private होते हैं)। टूल डिफ़ॉल्ट रूप से struct जनरेट करता है, डीसीरियलाइज़ेशन परिदृश्यों में struct का उपयोग अधिक संक्षिप्त और समझने में आसान होता है; यदि निजी सदस्यों + एक्सेसर विधियों को एनकैप्सुलेट करने की आवश्यकता है तो स्वयं class में बदला जा सकता है
std::string: C++ मानक लाइब्रेरी की स्ट्रिंग प्रकार (स्वामित्व सिमेंटिक्स), <string> में परिभाषित। यह टूल JSON स्ट्रिंग फ़ील्ड को स्वचालित रूप से std::string में मैप करता है, जैसे std::string name। ध्यान दें कि std::string C भाषा के char*/char[] से अलग है: std::string स्वचालित रूप से मेमोरी प्रबंधित करता है, ऑपरेटर ओवरलोडिंग (+, ==, <) का समर्थन करता है, लेकिन केवल छोटे से मध्यम लंबाई की स्ट्रिंग्स को प्रोसेस करते समय सबसे अच्छा प्रदर्शन करता है; बहुत लंबी स्ट्रिंग्स (जैसे पूर्ण लाइन लॉग 1KB+) के लिए std::string_view या कस्टम बफर का उपयोग करने की सिफारिश की जाती है
std::vector<T>: C++ मानक लाइब्रेरी का डायनेमिक ऐरे कंटेनर (<vector>), Java में ArrayList, Python में list, JavaScript में Array के बराबर। यह टूल JSON ऐरे फ़ील्ड को स्वचालित रूप से std::vector<T> में मैप करता है, जैसे std::vector<std::string> tags। लाभ: निरंतर मेमोरी, रैंडम एक्सेस O(1), पूंछ में जोड़ने का परिशोधित O(1); नुकसान: मध्य में सम्मिलन O(n)। निश्चित आकार के ऐरे की आवश्यकता होने पर std::array<T, N> (स्टैक पर आवंटित) का उपयोग किया जा सकता है
std::optional<T>: C++17 से मानक लाइब्रेरी का वैकल्पिक मान रैपर प्रकार (<optional>), यह दर्शाता है कि मान मौजूद नहीं हो सकता है। सामान्य उपयोग: std::optional<std::string> nickname; if (nickname) { use(*nickname); }। यह टूल null हो सकने वाले JSON फ़ील्ड को std::optional<T> के रूप में स्वीकार करता है, जैसे std::optional<std::string> nickname। यदि आपके प्रोजेक्ट को C++11/14 का उपयोग करने की आवश्यकता है तो boost::optional<T> से प्रतिस्थापित किया जा सकता है, API लगभग समान है
int64_t / double: int64_t <cstdint> में निश्चित-चौड़ाई 64-बिट पूर्णांक प्रकार उपनाम है, जो long long के बराबर, क्रॉस-प्लेटफॉर्म 8 बाइट की गारंटी देता है; double C++ का डबल-प्रिसिजन फ्लोटिंग पॉइंट प्रकार है (IEEE 754 double/binary64, लगभग 15-17 महत्वपूर्ण अंक)। यह टूल JSON पूर्णांकों को समान रूप से int64_t में मैप करता है, फ्लोटिंग पॉइंट को double में, क्रॉस-प्लेटफॉर्म long आकार असंगति (Windows पर long 32 बिट, Linux पर long 64 बिट) के कारण होने वाली सटीकता समस्याओं से बचता है। सटीक दशमलव (वित्तीय गणना) की आवश्यकता होने पर long double या decimal लाइब्रेरी का उपयोग किया जा सकता है
nlohmann::json: C++ पारिस्थितिकी तंत्र में सबसे लोकप्रिय JSON लाइब्रेरियों में से एक, जिसे nlohmann/json के रूप में भी जाना जाता है, जर्मनी के Niels Lohmann द्वारा जारी किया गया। मूल अवधारणा JSON डेटा स्ट्रक्चर को C++ मानक लाइब्रेरी प्रकारों (जैसे std::map, std::vector, std::string) में मैप करना है, डीसीरियलाइज़ेशन j.get<T>() के साथ एक पंक्ति में पूरा किया जा सकता है। इस टूल द्वारा जनरेट किया गया कोड स्वचालित डीसीरियलाइज़ेशन के लिए NLOHMANN_DEFINE_TYPE_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE जैसे मैक्रोज़ का उपयोग करके nlohmann/json के साथ काम कर सकता है। सिंगल-हेडर संदर्भ, समृद्ध दस्तावेज़ीकरण, STL-शैली API, अधिकांश C++ प्रोजेक्टों के लिए पसंदीदा विकल्प
rapidjson: Tencent की ओपन-सोर्स उच्च-प्रदर्शन C++ JSON लाइब्रेरी, लगभग 5k पंक्तियों का कोड, nlohmann::json की तुलना में लगभग 3-5 गुना उच्च प्रदर्शन, दो पार्सिंग शैलियों का समर्थन करती है: SAX (स्ट्रीमिंग) और DOM (दस्तावेज़ ऑब्जेक्ट मॉडल), SIMD निर्देशों (जैसे SSE42) के लिए विशेष त्वरण उपयोग है। सामान्य परिदृश्य: वित्तीय लेनदेन बाजार डेटा ट्रांसमिशन, गेम इंजन ऑब्जेक्ट सीरियलाइज़ेशन, एम्बेडेड सिस्टम में उच्च-प्रदर्शन लॉगिंग। इस टूल द्वारा जनरेट किए गए स्ट्रक्ट rapidjson Document/GenericValue के लिए लक्ष्य मॉडल के रूप में कार्य कर सकते हैं, लेकिन चूंकि rapidjson में टेम्पलेट रिफ्लेक्शन नहीं है, इसलिए GetObject/GetString के साथ स्वयं फ़ील्ड निष्कर्षण करने की आवश्यकता होती है
Web Worker / quicktype-core: Web Worker ब्राउज़र द्वारा प्रदान किया गया बैकग्राउंड थ्रेड API है, जो मुख्य थ्रेड के समानांतर काम करता है, मुख्य थ्रेड के DOM तक पहुंच नहीं सकता, केवल postMessage के माध्यम से संचार कर सकता है। quicktype-core ओपन-सोर्स JSON → बहु-भाषा कोड जनरेशन लाइब्रेरी है (GitHub: quicktype/quicktype), C++/Java/TypeScript/Rust/Go/Python/Swift सहित दस से अधिक भाषाओं का समर्थन करती है। यह टूल quicktype-core के आधार पर ब्राउज़र में C++ के लिए हेडर-ओनली स्ट्रक्ट कोड रेंडर करता है, मूल डेटा किसी भी सर्वर पर नहीं भेजा जाता, सभी पार्सिंग, जनरेशन, डाउनलोड ब्राउज़र में पूरे होते हैं। quicktype-core लोड करने वाला Worker मुख्य UI थ्रेड को ब्लॉक करने से बचता है
snake_case / camelCase / PascalCase: तीन मुख्य फ़ील्ड नामकरण शैलियां: snake_case (user_name, C/Python/DB में पसंदीदा), camelCase (userName, Java/JS में पसंदीदा), PascalCase (UserName, C#/Rust स्ट्रक्ट फ़ील्ड में पसंदीदा)। यह टूल डिफ़ॉल्ट रूप से JSON के मूल फ़ील्ड नाम (आमतौर पर snake_case) को बनाए रखता है, आप जनरेशन के बाद स्वयं अनुकूलित कर सकते हैं और मैपिंग घोषित करने के लिए NLOHMANN मैक्रोज़ जोड़ सकते हैं। ध्यान दें कि C++ सार्वजनिक फ़ील्ड नामकरण मानक camelCase या snake_case की सिफारिश करता है, PascalCase मुख्य रूप से क्लास नामों के लिए उपयोग किया जाता है (Google C++ Style), सदस्यों के लिए अनुशंसित नहीं; snake_case स्वाभाविक रूप से mySQL कॉलम नामों के अनुकूल है
NLOHMANN_DEFINE_TYPE_INTRUSIVE: nlohmann/json लाइब्रेरी द्वारा प्रदान किया गया मैक्रो, क्लास के भीतर JSON सीरियलाइज़ेशन फ़ील्ड मैपिंग घोषित करने के लिए उपयोग किया जाता है। सिंटैक्स NLOHMANN_DEFINE_TYPE_INTRUSIVE(ClassName, member1, member2, ...) है, सार्वजनिक क्षेत्र में रखा जाना चाहिए (ताकि मैक्रो निजी फ़ील्ड तक पहुंच सके)। गैर-आक्रामक संस्करण NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE क्लास के बाहर रखा जाता है, क्लास को स्वयं संशोधित करने की आवश्यकता नहीं होती। इस टूल द्वारा जनरेट किए गए स्ट्रक्ट स्वचालित रूप से ऐसे मैक्रोज़ नहीं जोड़ते हैं, आवश्यकता होने पर JSON कुंजियों और C++ सदस्यों के बीच संबंध घोषित करने के लिए स्वयं जोड़ें। यदि JSON फ़ील्ड नाम C++ सदस्य के समान है तो आप इस मैक्रो को छोड़ सकते हैं और सीधे j.get<T>() का उपयोग कर सकते हैं

JSON प्रकार से C++ प्रकार मैपिंग त्वरित संदर्भ तालिका

टूल JSON मान प्रकार के आधार पर स्वचालित रूप से संगत C++ प्रकार का अनुमान लगाएगा:

JSON मान उदाहरण	जनरेट किया गया C++ प्रकार	नोट
`null`	`std::optional<T>`	null मान प्रकार अनिश्चित, std::optional<T> (C++17+) द्वारा स्वीकार
`true / false`	`bool`	JSON बूलियन मान सीधे C++ bool में मैप
`42`	`int64_t`	JSON पूर्णांक डिफ़ॉल्ट रूप से int64_t (<cstdint>), long long के साथ संगत
`3.14`	`double`	JSON फ्लोटिंग पॉइंट डिफ़ॉल्ट रूप से double (IEEE 754 डबल-प्रिसिजन)
`"hello"`	`std::string`	JSON स्ट्रिंग std::string (<string>) में मैप
`["a","b"]`	`std::vector<std::string>`	स्ट्रिंग ऐरे std::vector<std::string> में मैप
`[1,2,3]`	`std::vector<int64_t>`	पूर्णांक ऐरे std::vector<int64_t> में मैप
`[{...},{...}]`	`std::vector<Item>`	ऑब्जेक्ट ऐरे पहले तत्व के अनुसार संगत स्ट्रक्ट जनरेट करते हैं, फिर std::vector के साथ लपेटते हैं
`[]`	`std::vector<nlohmann::json>`	खाली ऐरे तत्व प्रकार का अनुमान नहीं लगा सकता, nlohmann::json द्वारा स्वीकार (मैन्युअल रूप से std::vector<std::string> में भी लिखा जा सकता है)
`{...} नेस्टेड ऑब्जेक्ट`	`स्वतंत्र स्ट्रक्ट/क्लास`	नेस्टेड ऑब्जेक्ट स्वतंत्र स्ट्रक्ट जनरेट करते हैं, PascalCase नामकरण (address → Address)

लाइब्रेरी नाम	API शैली	प्रदर्शन	उपयुक्त परिदृश्य
`nlohmann::json`	`टेम्पलेट / STL-जैसी`	`मध्यम`	वेब बैकएंड, डेस्कटॉप एप्लिकेशन, शिक्षण; std::vector/std::map के साथ सबसे अच्छी संगतता
`rapidjson`	`SAX / DOM`	`बहुत उच्च`	वित्तीय लेनदेन, गेम इंजन, उच्च-थ्रूपुट सेवाएं; SIMD त्वरण का समर्थन
`Boost.JSON`	`Boost.Container`	`उच्च`	Boost पारिस्थितिकी तंत्र प्रोजेक्ट, वेब सर्वर (Beast/Asio)
`cJSON`	`C-शैली / फ़ंक्शन`	`उच्च`	C प्रोजेक्ट, C++ एम्बेडेड, C++ टेम्पलेट आयात नहीं करना चाहते परिदृश्य
`ArduinoJson`	`C++ टेम्पलेट`	`मध्यम`	Arduino, ESP32/ESP8266, एम्बेडेड MCU

C++ मानक लाइब्रेरी प्रकार और JSON संगतता त्वरित संदर्भ तालिका

JSON फ़ील्ड के अनुरूप C++ मानक लाइब्रेरी के मुख्य प्रकारों का अवलोकन, डेवलपर्स के त्वरित संदर्भ के लिए:

JSON कीवर्ड	संगत C++ मानक लाइब्रेरी प्रकार	आवश्यक हेडर फ़ाइल	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)/अंतर्निहित	C++98
null	std::optional<T>	<optional>	C++17
array	std::vector<T>	<vector>	C++98
निश्चित ऐरे	std::array<T, N>	<array>	C++11
ऑब्जेक्ट/map	std::map<std::string, T>	<map>	C++98
हैश ऑब्जेक्ट	std::unordered_map<K, T>	<unordered_map>	C++11
string view	std::string_view (गैर-स्वामी)	<string_view>	C++17
byte/char	std::byte/char	<cstddef>	C++17/C++98

Privacy & Security

इस JSON से C++ टूल के सभी ऑपरेशन पूरी तरह से आपके ब्राउज़र में पूरे होते हैं: JSON पार्सिंग, C++ स्ट्रक्ट जनरेशन और फ़ाइल डाउनलोड सभी ब्राउज़र के JavaScript (Web Worker + quicktype-core) के माध्यम से क्लाइंट-साइड पर पूरे होते हैं। कोई भी JSON डेटा, अपलोड की गई फ़ाइलें या जनरेट किया गया कोड नेटवर्क के माध्यम से किसी सर्वर पर नहीं भेजा जाएगा। फ़ाइल अपलोड ब्राउज़र के मूल FileReader API का उपयोग करके सीधे मेमोरी में पढ़ता है, किसी भी मध्यस्थ सेवा से नहीं गुजरता। कोई कुकी ट्रैकिंग नहीं, कोई उपयोगकर्ता इनपुट डेटा या उपयोग डेटा एकत्र नहीं किया जाता। पेज बंद करने या रीफ्रेश करने के बाद, सभी इनपुट और आउटपुट सामग्री स्वचालित रूप से मेमोरी से साफ हो जाएगी। API कुंजियों, टोकन, संवेदनशील व्यावसायिक डेटा वाले JSON को प्रोसेस करने के लिए उपयुक्त

Authoritative References

nlohmannnlohmann/json GitHub रिपॉजिटरी (nlohmann/json)
cppreferencecppreference - std::optional
cppreferencecppreference - std::vector
TencentRapidJSON GitHub रिपॉजिटरी (Tencent)
BoostBoost.JSON आधिकारिक दस्तावेज़ीकरण
ISO C++आधिकारिक ISO C++ मानक - isocpp.org