दिलचस्प पोस्ट
पूर्णांक की एक धारा से चलने वाली माध्य खोजें एसटीएल नक्शे के लिए ऑपरेटर कंट क्यों नहीं है? व्यू स्पेस गहराई मूल्य और एनएनडीसी xy को देखते हुए रिक्त स्थान को कैसे ठीक किया जाए एक सशर्त संकलन बयान का उपयोग किए बिना रनटाइम पर ओएस संस्करण की जांच कैसे करें जैसे विंडो या लिनक्स क्या एक्लिप्स में स्रोत संलग्न करने का एक आसान तरीका है? गेटवे.sandbox.push.apple.com से कनेक्ट करते समय "त्रुटि सत्यापित करें: num = 20" Google खोज परिणामों में वेबसाइट शीर्षक को अलग-अलग प्रदर्शित करता है स्क्रीन के आईओएस स्क्रीनशॉट भाग मेवेन-छाया-प्लगइन क्या उपयोग किया जाता है, और आप जावा पैकेजों को क्यों स्थानांतरित करना चाहते हैं? HTML5 ब्राउज़र में एकल छवि अनुरोध को रद्द करें पुराने "प्रकारों की ऐम" पैटर्न पर जावा की गिनती का लाभ? स्विफ्ट 3.0 और एनएस एनोटिफिकेशन सेंटर में सूचना 2.0 का इस्तेमाल करते हुए डाटा कैसे पहुंचे? क्या कोई C ++ क्लास सदस्य फ़ंक्शन टेम्पलेट आभासी हो सकता है? Graphics2D.drawString में नई लाइन के साथ समस्याएं एकाधिक घटनाओं को खोजने के लिए PHP preg_match

Utf16 को द्विआधारी मोड में लिखना

मैं द्विआधारी मोड में ऑफस्ट्र्रीम के साथ फाइल करने के लिए एक wstring लिखने की कोशिश कर रहा हूं, लेकिन मुझे लगता है कि मैं कुछ गलत कर रहा हूं। यह मैंने कोशिश की है:

ofstream outFile("test.txt", std::ios::out | std::ios::binary); wstring hello = L"hello"; outFile.write((char *) hello.c_str(), hello.length() * sizeof(wchar_t)); outFile.close(); 

उदाहरण के लिए फ़ायरफ़ॉक्स के साथ testtxt खोलना, जो कि यूटीएफ 16 पर सेट एन्कोडिंग के रूप में दिखाएगा:

नमस्ते

क्या कोई मुझे बता सकता है कि ऐसा क्यों होता है?

संपादित करें:

हेक्स एडिटर में फाइल खोलना मुझे मिल रहा है:

 FF FE 68 00 00 00 65 00 00 00 6C 00 00 00 6C 00 00 00 6F 00 00 00 

ऐसा लगता है कि मुझे किसी भी कारण से प्रत्येक चरित्र के बीच दो अतिरिक्त बाइट मिलते हैं?

Solutions Collecting From Web of "Utf16 को द्विआधारी मोड में लिखना"

मुझे संदेह है कि sizeof (wchar_t) आपके पर्यावरण में 4 है – यानी यह UTF-32 / UCS-4 को UTF-16 के बजाय लिख रहा है निश्चित रूप से हेक्स डंप क्या दिखता है

यह परीक्षण करने के लिए बहुत आसान है (बस आकार के आकार (wchar_t) को प्रिंट करें), लेकिन मुझे पूरा यकीन है कि यह क्या हो रहा है।

UTF-32 wstring से UTF-16 तक जाने के लिए आपको एक उचित एन्कोडिंग लागू करने की आवश्यकता होगी, क्योंकि सरोगेट जोड़े खेलने में आते हैं।

यहां हम छोटे प्रयोग किए जाने वाले स्थान के गुणों में भाग लेते हैं। यदि आप अपनी स्ट्रिंग स्ट्रिंग (कच्चे डेटा के बजाय) के रूप में आउटपुट करते हैं तो आप लोकेल को उपयुक्त रूपांतरण ऑटो-जादुई रूप से प्राप्त कर सकते हैं

NB यह कोड wchar_t वर्ण के edianness खाते में नहीं ले करता है।

 #include <locale> #include <fstream> #include <iostream> // See Below for the facet #include "UTF16Facet.h" int main(int argc,char* argv[]) { // construct a custom unicode facet and add it to a local. UTF16Facet *unicodeFacet = new UTF16Facet(); const std::locale unicodeLocale(std::cout.getloc(), unicodeFacet); // Create a stream and imbue it with the facet std::wofstream saveFile; saveFile.imbue(unicodeLocale); // Now the stream is imbued we can open it. // NB If you open the file stream first. Any attempt to imbue it with a local will silently fail. saveFile.open("output.uni"); saveFile << L"This is my Data\n"; return(0); } 

फ़ाइल: UTF16Facet.h

  #include <locale> class UTF16Facet: public std::codecvt<wchar_t,char,std::char_traits<wchar_t>::state_type> { typedef std::codecvt<wchar_t,char,std::char_traits<wchar_t>::state_type> MyType; typedef MyType::state_type state_type; typedef MyType::result result; /* This function deals with converting data from the input stream into the internal stream.*/ /* * from, from_end: Points to the beginning and end of the input that we are converting 'from'. * to, to_limit: Points to where we are writing the conversion 'to' * from_next: When the function exits this should have been updated to point at the next location * to read from. (ie the first unconverted input character) * to_next: When the function exits this should have been updated to point at the next location * to write to. * * status: This indicates the status of the conversion. * possible values are: * error: An error occurred the bad file bit will be set. * ok: Everything went to plan * partial: Not enough input data was supplied to complete any conversion. * nonconv: no conversion was done. */ virtual result do_in(state_type &s, const char *from,const char *from_end,const char* &from_next, wchar_t *to, wchar_t *to_limit,wchar_t* &to_next) const { // Loop over both the input and output array/ for(;(from < from_end) && (to < to_limit);from += 2,++to) { /*Input the Data*/ /* As the input 16 bits may not fill the wchar_t object * Initialise it so that zero out all its bit's. This * is important on systems with 32bit wchar_t objects. */ (*to) = L'\0'; /* Next read the data from the input stream into * wchar_t object. Remember that we need to copy * into the bottom 16 bits no matter what size the * the wchar_t object is. */ reinterpret_cast<char*>(to)[0] = from[0]; reinterpret_cast<char*>(to)[1] = from[1]; } from_next = from; to_next = to; return((from > from_end)?partial:ok); } /* This function deals with converting data from the internal stream to a C/C++ file stream.*/ /* * from, from_end: Points to the beginning and end of the input that we are converting 'from'. * to, to_limit: Points to where we are writing the conversion 'to' * from_next: When the function exits this should have been updated to point at the next location * to read from. (ie the first unconverted input character) * to_next: When the function exits this should have been updated to point at the next location * to write to. * * status: This indicates the status of the conversion. * possible values are: * error: An error occurred the bad file bit will be set. * ok: Everything went to plan * partial: Not enough input data was supplied to complete any conversion. * nonconv: no conversion was done. */ virtual result do_out(state_type &state, const wchar_t *from, const wchar_t *from_end, const wchar_t* &from_next, char *to, char *to_limit, char* &to_next) const { for(;(from < from_end) && (to < to_limit);++from,to += 2) { /* Output the Data */ /* NB I am assuming the characters are encoded as UTF-16. * This means they are 16 bits inside a wchar_t object. * As the size of wchar_t varies between platforms I need * to take this into consideration and only take the bottom * 16 bits of each wchar_t object. */ to[0] = reinterpret_cast<const char*>(from)[0]; to[1] = reinterpret_cast<const char*>(from)[1]; } from_next = from; to_next = to; return((to > to_limit)?partial:ok); } }; 

यदि आप C++11 मानक का उपयोग करते हैं, तो यह आसान है (क्योंकि इसमें बहुत सारे अतिरिक्त "utf8" शामिल हैं जो इस समस्या को हमेशा के लिए हल करता है)।

लेकिन अगर आप पुराने मानकों के साथ मल्टी-प्लेटफ़ॉर्म कोड का उपयोग करना चाहते हैं, तो आप धाराओं के साथ लिखने के लिए इस विधि का उपयोग कर सकते हैं:

  1. धाराओं के लिए यूटीएफ कनवर्टर के बारे में लेख पढ़ें
  2. ऊपर से स्रोतों से अपनी परियोजना में stxutif.h जोड़ें
  3. फ़ाइल को एएनएसआई मोड में खोलें और फ़ाइल की शुरुआत में BOM को जोड़ दें, जैसे:

     std::ofstream fs; fs.open(filepath, std::ios::out|std::ios::binary); unsigned char smarker[3]; smarker[0] = 0xEF; smarker[1] = 0xBB; smarker[2] = 0xBF; fs << smarker; fs.close(); 
  4. तब फ़ाइल को UTF रूप में खोलें और वहां अपनी सामग्री लिखें:

     std::wofstream fs; fs.open(filepath, std::ios::out|std::ios::app); std::locale utf8_locale(std::locale(), new utf8cvt<false>); fs.imbue(utf8_locale); fs << .. // Write anything you want... 

Wofstream का उपयोग करके खिड़कियों पर और ऊपर परिभाषित utf16 पहलू विफल हो जाता है क्योंकि wofstream सभी बाइट्स को मान 0 ए से 2 बाइट्स 0 डी 0 ए के साथ कनवर्ट करता है, इस तरह से आप 0A बाइट को '\ x0A', L '\ x0A' एल '\ x000A', '\ n', एल '\ n' और std :: endl सभी समान परिणाम देते हैं खिड़कियों पर आप को द्विआधारी मोड में एक ऑफस्ट्रीम (नहीं wofsteam) के साथ फ़ाइल खोलना होगा और आउटपुट को लिखना जैसे यह मूल पोस्ट में किया जाता है

प्रदान की गई Utf16Facet बड़ी स्ट्रिंग के लिए gcc में काम नहीं कर रहा था, यहां वह संस्करण है जो मेरे लिए काम करता है … इस तरह से फ़ाइल UTF-16LE में सहेजी जाएगी। UTF-16BE , बस do_in और do_out में असाइनमेंट को पलटना, जैसे to[0] = from[1] और to[1] = from[0]

 #include <locale> #include <bits/codecvt.h> class UTF16Facet: public std::codecvt<wchar_t,char,std::char_traits<wchar_t>::state_type> { typedef std::codecvt<wchar_t,char,std::char_traits<wchar_t>::state_type> MyType; typedef MyType::state_type state_type; typedef MyType::result result; /* This function deals with converting data from the input stream into the internal stream.*/ /* * from, from_end: Points to the beginning and end of the input that we are converting 'from'. * to, to_limit: Points to where we are writing the conversion 'to' * from_next: When the function exits this should have been updated to point at the next location * to read from. (ie the first unconverted input character) * to_next: When the function exits this should have been updated to point at the next location * to write to. * * status: This indicates the status of the conversion. * possible values are: * error: An error occurred the bad file bit will be set. * ok: Everything went to plan * partial: Not enough input data was supplied to complete any conversion. * nonconv: no conversion was done. */ virtual result do_in(state_type &s, const char *from,const char *from_end,const char* &from_next, wchar_t *to, wchar_t *to_limit,wchar_t* &to_next) const { for(;from < from_end;from += 2,++to) { if(to<=to_limit){ (*to) = L'\0'; reinterpret_cast<char*>(to)[0] = from[0]; reinterpret_cast<char*>(to)[1] = from[1]; from_next = from; to_next = to; } } return((to != to_limit)?partial:ok); } /* This function deals with converting data from the internal stream to a C/C++ file stream.*/ /* * from, from_end: Points to the beginning and end of the input that we are converting 'from'. * to, to_limit: Points to where we are writing the conversion 'to' * from_next: When the function exits this should have been updated to point at the next location * to read from. (ie the first unconverted input character) * to_next: When the function exits this should have been updated to point at the next location * to write to. * * status: This indicates the status of the conversion. * possible values are: * error: An error occurred the bad file bit will be set. * ok: Everything went to plan * partial: Not enough input data was supplied to complete any conversion. * nonconv: no conversion was done. */ virtual result do_out(state_type &state, const wchar_t *from, const wchar_t *from_end, const wchar_t* &from_next, char *to, char *to_limit, char* &to_next) const { for(;(from < from_end);++from, to += 2) { if(to <= to_limit){ to[0] = reinterpret_cast<const char*>(from)[0]; to[1] = reinterpret_cast<const char*>(from)[1]; from_next = from; to_next = to; } } return((to != to_limit)?partial:ok); } }; 

आपको हेक्स एडिटर जैसे आउटपुट फाइल को देखना चाहिए जैसे कि विंहेक्स ताकि आप वास्तविक बिट्स और बाइट्स देख सकें, यह सत्यापित करने के लिए कि वास्तव में आउटपुट UTF-16 है इसे यहां पोस्ट करें और हमें परिणाम का पता करें। यह हमें बताएगा कि क्या फ़ायरफ़ॉक्स या आपके सी ++ प्रोग्राम को दोष देना है।

लेकिन यह मुझे आपके सी ++ कार्यक्रम कार्यों की तरह दिखता है और फ़ायरफ़ॉक्स आपके UTF-16 को सही ढंग से व्याख्या नहीं कर रहा है UTF-16 प्रत्येक चरित्र के लिए दो बाइट्स के लिए कॉल करता है। लेकिन फ़ायरफ़ॉक्स कई अक्षरों के रूप में दो बार छपाई कर रहा है जैसे कि यह चाहिए, इसलिए यह संभवत: आपकी स्ट्रिंग को यूटीएफ -8 या एएससीसीआई के रूप में परिभाषित करने की कोशिश कर रहा है, जो आमतौर पर केवल 1 बाइट प्रति चरित्र है।

जब आप "फ़ायरफ़ॉक्स के साथ एन्कोडिंग सेट यूटीएफ 16" कहते हैं तो आप क्या कह रहे हैं? मुझे संदेह है कि वह काम है