c++ - std:: wstring वीएस std:: स्ट्रिंग




unicode c++-faq (8)

string ? wstring ?

std::string एक basic_string एक char पर templated है, और std::wstring पर std::wstring

char बनाम wchar_t

char को एक चरित्र पकड़ना होता है, आमतौर पर 1-बाइट वर्ण होता है। wchar_t को एक विस्तृत चरित्र धारण करना चाहिए, और फिर, चीजें मुश्किल हो जाती हैं: लिनक्स पर, wchar_t 4 बाइट्स है, जबकि विंडोज़ पर, यह 2 बाइट्स है

Unicode बारे में क्या?

समस्या यह है कि न तो char और न ही wchar_t सीधे यूनिकोड से बंधे हैं।

लिनक्स पर?

आइए एक लिनक्स ओएस लें: मेरा उबंटू सिस्टम पहले से ही यूनिकोड जागरूक है। जब मैं एक चार स्ट्रिंग के साथ काम करता हूं, तो यह मूल रूप से UTF-8 (यानी वर्णों की यूनिकोड स्ट्रिंग) में एन्कोड किया जाता है। निम्नलिखित कोड:

#include <cstring>
#include <iostream>

int main(int argc, char* argv[])
{
   const char text[] = "olé" ;


   std::cout << "sizeof(char)    : " << sizeof(char) << std::endl ;
   std::cout << "text            : " << text << std::endl ;
   std::cout << "sizeof(text)    : " << sizeof(text) << std::endl ;
   std::cout << "strlen(text)    : " << strlen(text) << std::endl ;

   std::cout << "text(bytes)     :" ;

   for(size_t i = 0, iMax = strlen(text); i < iMax; ++i)
   {
      std::cout << " " << static_cast<unsigned int>(
                              static_cast<unsigned char>(text[i])
                          );
   }

   std::cout << std::endl << std::endl ;

   // - - - 

   const wchar_t wtext[] = L"olé" ;

   std::cout << "sizeof(wchar_t) : " << sizeof(wchar_t) << std::endl ;
   //std::cout << "wtext           : " << wtext << std::endl ; <- error
   std::cout << "wtext           : UNABLE TO CONVERT NATIVELY." << std::endl ;
   std::wcout << L"wtext           : " << wtext << std::endl;

   std::cout << "sizeof(wtext)   : " << sizeof(wtext) << std::endl ;
   std::cout << "wcslen(wtext)   : " << wcslen(wtext) << std::endl ;

   std::cout << "wtext(bytes)    :" ;

   for(size_t i = 0, iMax = wcslen(wtext); i < iMax; ++i)
   {
      std::cout << " " << static_cast<unsigned int>(
                              static_cast<unsigned short>(wtext[i])
                              );
   }

   std::cout << std::endl << std::endl ;

   return 0;
}

निम्नलिखित पाठ आउटपुट करता है:

sizeof(char)    : 1
text            : olé
sizeof(text)    : 5
strlen(text)    : 4
text(bytes)     : 111 108 195 169

sizeof(wchar_t) : 4
wtext           : UNABLE TO CONVERT NATIVELY.
wtext           : ol�
sizeof(wtext)   : 16
wcslen(wtext)   : 3
wtext(bytes)    : 111 108 233

आप देखेंगे कि char में "ओले" टेक्स्ट वास्तव में चार वर्णों द्वारा निर्मित किया गया है: 110, 108, 1 9 और 16 9 (पीछे की ओर गिनती नहीं)। (मैं आपको अभ्यास के रूप में wchar_t कोड का अध्ययन करने दूंगा)

इसलिए, लिनक्स पर एक char के साथ काम करते समय, आपको आमतौर पर यूनिकोड का उपयोग किए बिना इसे समाप्त करना चाहिए। और चूंकि std :: स्ट्रिंग char के साथ काम करता है, इसलिए std :: string पहले से ही यूनिकोड-तैयार है।

ध्यान दें कि सी स्ट्रिंग एपीआई की तरह std :: स्ट्रिंग, "olé" स्ट्रिंग पर 4 वर्ण होने पर विचार करेगी, तीन नहीं। तो आपको यूनिकोड वर्णों के साथ छेड़छाड़ / खेलते समय सावधान रहना चाहिए क्योंकि यूटीएफ -8 में वर्णों का कुछ संयोजन प्रतिबंधित है।

विंडोज़ पर?

विंडोज़ पर, यह थोड़ा अलग है। Win32 को यूनिकोड के आगमन से पहले, दुनिया भर में उत्पादित विभिन्न charsets / codepages पर काम करने के लिए बहुत से आवेदन का समर्थन करना पड़ा।

तो उनका समाधान एक दिलचस्प था: यदि कोई एप्लिकेशन char साथ काम करता है, तो चार तारों को मशीन पर स्थानीय वर्णसेट / कोडपेज का उपयोग करके जीयूआई लेबल पर एन्कोड / मुद्रित / दिखाया जाता है। उदाहरण के लिए, फ्रांसीसी-स्थानीय विंडोज़ में "ओले" "ओले" होगा, लेकिन यदि आप Windows-1251 उपयोग करते हैं तो एक साइरिलिक-स्थानीय विंडोज ("olй" पर कुछ भिन्न होगा)। इस प्रकार, "ऐतिहासिक ऐप्स" आमतौर पर वही पुराने तरीके से काम करेंगे।

यूनिकोड आधारित अनुप्रयोगों के लिए, विंडोज wchar_t का उपयोग करता है, जो 2-बाइट चौड़ा है, और UTF-16 में एन्कोड किया गया है, जो यूनिकोड 2-बाइट वर्णों पर एन्कोड किया गया है (या कम से कम, अधिकतर संगत यूसीएस -2, जो लगभग है एक ही बात आईआईआरसी)।

char का उपयोग करने वाले अनुप्रयोगों को "मल्टीबाइट" कहा जाता है (क्योंकि प्रत्येक ग्लिफ एक या अधिक char से बना होता है), जबकि wchar_t का उपयोग करने वाले अनुप्रयोगों को "वाइडचर" कहा जाता है (क्योंकि प्रत्येक ग्लिफ एक या दो wchar_t से बना होता है। WideCharToMultiByte और WideCharToMultiByte रूपांतरण API देखें अधिक जानकारी के लिए।

इस प्रकार, यदि आप विंडोज पर काम करते हैं, तो आप बुरी तरह से wchar_t का उपयोग करना चाहते हैं (जब तक कि आप उस फ्रेमवर्क का उपयोग न करें, जैसे GTK+ या QT ...)। तथ्य यह है कि दृश्यों के पीछे, विंडोज wchar_t तारों के साथ काम करता है, इसलिए यहां तक ​​कि ऐतिहासिक अनुप्रयोगों में उनके char स्ट्रिंग्स को wchar_t में परिवर्तित किया जाएगा जब एपीआई का उपयोग करते हुए SetWindowText (Win32 GUI पर लेबल सेट करने के लिए निम्न स्तर API फ़ंक्शन)।

मेमोरी मुद्दे?

यूटीएफ -32 प्रति वर्ण 4 बाइट्स है, इसलिए इसमें जोड़ने के लिए बहुत कुछ नहीं है, अगर केवल यूटीएफ -8 टेक्स्ट और यूटीएफ -16 टेक्स्ट यूटीएफ -32 टेक्स्ट की तुलना में कम या समान मात्रा में स्मृति का उपयोग करेगा (और आमतौर पर कम )।

यदि कोई स्मृति समस्या है, तो आपको सबसे पश्चिमी भाषाओं की तुलना में पता होना चाहिए, यूटीएफ -8 पाठ उसी यूटीएफ -16 की तुलना में कम स्मृति का उपयोग करेगा।

फिर भी, अन्य भाषाओं (चीनी, जापानी, आदि) के लिए, उपयोग की गई स्मृति या तो यूटीएफ -16 के मुकाबले यूटीएफ -8 के लिए समान होगी।

सब कुछ, यूटीएफ -16 अधिकतर प्रति अक्षर 2 बाइट्स का उपयोग करेगा (जब तक कि आप किसी प्रकार की गूढ़ भाषा ग्लिफ (क्लिंगन? एल्विश?) से निपट रहे हों, जबकि यूटीएफ -8 1 से 4 बाइट्स खर्च करेगा।

अधिक जानकारी के लिए http://en.wikipedia.org/wiki/UTF-8#Compared_to_UTF-16 देखें।

निष्कर्ष

1. जब मुझे std :: स्ट्रिंग पर std :: wstring का उपयोग करना चाहिए?

लिनक्स पर? लगभग नहीं (§)।
विंडोज़ पर? ज्यादातर हमेशा (§)।
क्रॉस-प्लेटफ़ॉर्म कोड पर? आपके टूलकिट पर निर्भर करता है ...

(§): जब तक कि आप अन्यथा कहने वाले टूलकिट / फ्रेमवर्क का उपयोग न करें

2. क्या std :: स्ट्रिंग विशेष अक्षर सहित सभी ASCII वर्ण सेट को रोक सकता है?

नोटिस: एक std :: स्ट्रिंग 'बाइनरी' बफर रखने के लिए उपयुक्त है, जहां एक std :: wstring नहीं है!

लिनक्स पर? हाँ।
विंडोज़ पर? विंडोज उपयोगकर्ता के वर्तमान लोकेल के लिए केवल विशेष पात्र उपलब्ध हैं।

संपादित करें ( जोहान गेरेल से एक टिप्पणी के बाद): एक std :: स्ट्रिंग सभी चार आधारित तारों को संभालने के लिए पर्याप्त होगी (प्रत्येक char 0 से 255 तक की संख्या है)। परंतु:

  1. एएससीआईआई को 0 से 127 तक जाना है। उच्चतर वर्ण ASCII नहीं हैं।
  2. 0 से 127 तक का एक चार्ट सही ढंग से आयोजित किया जाएगा
  3. 128 से 255 के एक चार्ट में आपके एन्कोडिंग (यूनिकोड, गैर-यूनिकोड इत्यादि) के आधार पर एक संकेत होगा, लेकिन यह यूटीएफ -8 में एन्कोड किए जाने तक सभी यूनिकोड ग्लाइफ को पकड़ पाएगा।

3. क्या std :: wstring लगभग सभी लोकप्रिय C ++ कंपाइलर्स द्वारा समर्थित है?

ज्यादातर, जीसीसी आधारित कंपाइलर्स के अपवाद के साथ जो विंडोज को पोर्ट किए जाते हैं
यह मेरे जी ++ 4.3.2 (लिनक्स के तहत) पर काम करता है, और मैंने विजुअल सी ++ 6 के बाद से Win32 पर यूनिकोड एपीआई का उपयोग किया।

4. वास्तव में एक विस्तृत चरित्र क्या है?

सी / सी ++ पर, यह एक चरित्र प्रकार लिखा गया है wchar_t जो कि सरल char वर्ण प्रकार से बड़ा है। यह उन पात्रों को रखने के लिए उपयोग किया जाना चाहिए जिनके सूचकांक (जैसे यूनिकोड ग्लाइफ) 255 से अधिक (या 127, निर्भर करता है ...)

मैं std::string और std::wstring बीच अंतर को समझने में सक्षम नहीं हूं। मुझे पता है कि wstring यूनिकोड वर्णों जैसे विस्तृत वर्णों का समर्थन करता है। मुझे निम्नलिखित प्रश्न हैं:

  1. मुझे std::string पर std::string std::wstring उपयोग कब करना चाहिए?
  2. क्या std::string विशेष ASCII चरित्र सेट को पकड़ सकता है, जिसमें विशेष वर्ण भी शामिल हैं?
  3. क्या सभी लोकप्रिय सी ++ कंपाइलर्स द्वारा समर्थित std::wstring ?
  4. वास्तव में एक " विस्तृत चरित्र " क्या है?

  1. जब आप 'विस्तृत' (यूनिकोड) वर्णों को स्टोर करना चाहते हैं।
  2. हां: उनमें से 255 (0 को छोड़कर)।
  3. हाँ।
  4. यहां एक प्रारंभिक लेख है: http://www.joelonsoftware.com/articles/Unicode.html

  1. जब आप अपनी स्ट्रिंग में विस्तृत अक्षर संग्रहित करना चाहते हैं। wide कार्यान्वयन पर निर्भर करता है। यदि मैं सही ढंग से याद करता हूं, तो विज़ुअल सी ++ 16 बिट पर डिफ़ॉल्ट होता है, जबकि लक्ष्य के आधार पर जीसीसी डिफ़ॉल्ट होता है। यहां 32 बिट लंबा है। कृपया ध्यान दें wchar_t (विस्तृत वर्ण प्रकार) के पास यूनिकोड के साथ कुछ लेना देना नहीं है। यह केवल गारंटी है कि यह सबसे बड़े चरित्र सेट के सभी सदस्यों को स्टोर कर सकता है कि कार्यान्वयन इसके लोकेशंस द्वारा समर्थित है, और कम से कम जब तक चार। आप utf-8 एन्कोडिंग का उपयोग कर यूनिकोड स्ट्रिंग्स को std::string में भी स्टोर कर सकते हैं। लेकिन यह यूनिकोड कोड बिंदुओं के अर्थ को समझ नहीं पाएगा। तो str.size() आपको आपकी स्ट्रिंग में तार्किक वर्णों की मात्रा नहीं देगा, लेकिन उस स्ट्रिंग / wstring में संग्रहीत char या wchar_t तत्वों की मात्रा केवल। इसी कारण से, gtk / glib c ++ Glib::ustring लोगों ने एक Glib::ustring क्लास विकसित किया है जो utf-8 को संभाल सकता है।

    यदि आपका wchar_t 32 बिट लंबा है, तो आप utf-32 को यूनिकोड एन्कोडिंग के रूप में उपयोग कर सकते हैं, और आप एक निश्चित (utf-32 निश्चित लंबाई) एन्कोडिंग का उपयोग करके यूनिकोड स्ट्रिंग को स्टोर और संभाल सकते हैं। इसका मतलब है कि आपके wstring का s.size() फ़ंक्शन फिर wchar_t तत्वों और तार्किक वर्णों की सही मात्रा को वापस कर देगा।

  2. हां, char हमेशा कम से कम 8 बिट लंबा होता है, जिसका अर्थ है कि यह सभी ASCII मानों को स्टोर कर सकता है।
  3. हां, सभी प्रमुख कंपाइलर्स इसका समर्थन करते हैं।

1) ग्रेग द्वारा वर्णित अनुसार, अंतर्राष्ट्रीयकरण के लिए wstring सहायक है, यही वह समय है जब आप अंग्रेजी के अलावा अन्य भाषाओं में अपना उत्पाद जारी करेंगे

4) विस्तृत चरित्र wchar_t लिए इसे देखें


इसलिए, यहां हर पाठक को तथ्यों, स्थिति के बारे में स्पष्ट समझ होनी चाहिए। यदि नहीं, तो आपको पेर्सबल के उत्कृष्ट व्यापक उत्तर को पढ़ना होगा [ बीटीडब्ल्यू : धन्यवाद!]।

मेरा व्यावहारिक निष्कर्ष चौंकाने वाला सरल है: सी ++ (और एसटीएल) "चरित्र एन्कोडिंग" सामान सब कुछ टूटा हुआ और बेकार है। इसे माइक्रोसॉफ्ट पर दोष दें या नहीं, जो वैसे भी मदद नहीं करेगा।

मेरा समाधान, गहन जांच के बाद, बहुत निराशा और परिणामी अनुभव निम्नलिखित हैं:

  1. स्वीकार करें, कि आपको एन्कोडिंग और रूपांतरण सामग्री के लिए अपने आप पर ज़िम्मेदार होना होगा (और आप देखेंगे कि इसमें से अधिकतर मामूली है)

  2. किसी भी यूटीएफ -8 एन्कोडेड तारों के लिए std :: स्ट्रिंग का उपयोग करें (केवल एक typedef std::string UTF8String )

  3. स्वीकार करें कि ऐसी यूटीएफ 8 स्ट्रिंग ऑब्जेक्ट सिर्फ एक गूंगा है, लेकिन सस्ते कंटेनर है। कभी भी इसमें वर्णों को कभी भी एक्सेस न करें और / या मैनिपुलेट करें (कोई खोज, प्रतिस्थापन नहीं, और इसी तरह)। आप कर सकते हैं, लेकिन आप वास्तव में वास्तव में, वास्तव में बहु-बाइट तारों के लिए पाठ मैनिपुलेशन एल्गोरिदम लिखने में अपना समय बर्बाद नहीं करना चाहते हैं! यहां तक ​​कि अगर अन्य लोगों ने पहले से ही ऐसी बेवकूफ चीजें की हैं, तो ऐसा मत करो! होने दो! (ठीक है, ऐसे परिदृश्य हैं जहां यह समझ में आता है ... केवल उन लोगों के लिए आईसीयू लाइब्रेरी का उपयोग करें)।

  4. यूसीएस -2 एन्कोडेड तारों के लिए std :: wstring का उपयोग करें ( typedef std::wstring UCS2String ) - यह एक समझौता है, और WIN32 एपीआई की गड़बड़ी के लिए रियायत है)। यूसीएस -2 हमारे अधिकांश के लिए पर्याप्त है (उस पर और बाद में ...)।

  5. जब भी एक चरित्र-दर-चरित्र पहुंच की आवश्यकता होती है (पढ़ें, छेड़छाड़ करें, और इसी तरह) UCS2String उदाहरणों का उपयोग करें। किसी भी चरित्र-आधारित प्रसंस्करण को गैर-मल्टीबाइट-प्रस्तुति में किया जाना चाहिए। यह सरल, तेज़, आसान है।

  6. यूटीएफ -8 और यूसीएस -2 के बीच आगे और आगे परिवर्तित करने के लिए दो उपयोगिता कार्यों को जोड़ें:

    UCS2String ConvertToUCS2( const UTF8String &str );
    UTF8String ConvertToUTF8( const UCS2String &str );
    

रूपांतरण सरल हैं, Google को यहां सहायता करनी चाहिए ...

बस। जहां भी स्मृति कीमती है और सभी यूटीएफ -8 I / O के लिए UTF8String का उपयोग करें। यूसीएस 2 स्ट्रिंग का प्रयोग करें जहां स्ट्रिंग को पार्स किया जाना चाहिए और / या छेड़छाड़ की जानी चाहिए। आप किसी भी समय उन दो प्रतिनिधियों के बीच परिवर्तित कर सकते हैं।

विकल्प और सुधार

  • एकल-बाइट वर्ण एन्कोडिंग (जैसे आईएसओ const wchar_t tt_iso88951[256] = {0,1,2,...}; 9 -1) से रूपांतरणों को सादा अनुवाद तालिकाओं की सहायता से महसूस किया जा सकता है, उदाहरण के लिए const wchar_t tt_iso88951[256] = {0,1,2,...}; और यूसीएस 2 से रूपांतरण के लिए उपयुक्त कोड।

  • यदि UCS-2 पर्याप्त नहीं है, तो यूसीएस -4 ( typedef std::basic_string<uint32_t> UCS2String ) पर स्विच करने से

आईसीयू या अन्य यूनिकोड पुस्तकालयों?

उन्नत सामान के लिए।


एक अच्छा सवाल! मुझे लगता है कि डाटा एनकोडिंग (कभी-कभी चार्जेट भी शामिल है) नेटवर्क के माध्यम से डेटा को फाइल करने या स्थानांतरित करने के लिए डेटा को सहेजने के लिए एक स्मृति अभिव्यक्ति तंत्र है, इसलिए मैं इस प्रश्न का उत्तर इस प्रकार देता हूं:

1. मुझे std :: स्ट्रिंग पर std :: wstring का उपयोग कब करना चाहिए?

यदि प्रोग्रामिंग प्लेटफॉर्म या एपीआई फ़ंक्शन एक-बाइट एक है, और हम कुछ यूनिकोड डेटा को संसाधित या पार्स करना चाहते हैं, उदाहरण के लिए विंडोज '.REG फ़ाइल या नेटवर्क 2-बाइट स्ट्रीम से पढ़ें, हमें std :: wstring चर को आसान बनाना चाहिए उन्हें संसाधित करें। उदाहरण: wstring ws = एल "中国 a" (6 octets स्मृति: 0x4E2D 0x56FD 0x0061), हम अक्षर '' 'और ws [1] प्राप्त करने के लिए ws [0] का उपयोग कर सकते हैं चरित्र' 国 'और ws [2] चरित्र 'ए', आदि प्राप्त करें

2. कर सकते हैं std :: स्ट्रिंग विशेष ASCII चरित्र सेट, विशेष पात्रों सहित?

हाँ। लेकिन ध्यान दें: अमेरिकी एएससीआईआई का मतलब है कि प्रत्येक चरित्र के लिए प्रत्येक 0x00 ~ 0xFF ऑक्टेट स्टैंड है, जिसमें "123abc & * _ &" जैसे प्रिंट करने योग्य टेक्स्ट शामिल हैं और आपने विशेष कहा है, ज्यादातर इसे '।' के रूप में प्रिंट करते हैं। भ्रमित संपादकों या टर्मिनल से बचें। और कुछ अन्य देश अपने स्वयं के "ASCII" वर्णमाला का विस्तार करते हैं, उदाहरण के लिए चीनी, एक चरित्र के लिए खड़े होने के लिए 2 ऑक्टेट का उपयोग करें।

3. क्या सभी लोकप्रिय सी ++ कंपाइलर्स द्वारा समर्थित std :: wstring है?

शायद, या अधिकतर। मैंने उपयोग किया है: वीसी ++ 6 और जीसीसी 3.3, हाँ

4. वास्तव में एक "विस्तृत चरित्र" क्या है?

व्यापक चरित्र ज्यादातर देशों के पात्रों को पकड़ने के लिए 2 ऑक्टेट या 4 ऑक्टेट्स का उपयोग करते हैं। 2 ऑक्टेट्स यूसीएस 2 एक प्रतिनिधि नमूना है, और आगे जैसे अंग्रेजी 'ए', इसकी याददाश्त 0x0061 के 2 ऑक्टेट है (बनाम एएससीआईआई की ए मेमोरी 1 ऑक्टेट 0x61 है)


मैं अक्सर बिना किसी समस्या के utf-8 अक्षरों को पकड़ने के लिए std :: स्ट्रिंग का उपयोग करता हूं। मैं एपीआई के साथ इंटरफेसिंग करते समय दिल से यह करने की सलाह देता हूं जो देशी स्ट्रिंग प्रकार के रूप में utf-8 का उपयोग करता है।

उदाहरण के लिए, मैं अपने कोड को टीसीएल दुभाषिया के साथ इंटरफेस करते समय utf-8 का उपयोग करता हूं।

प्रमुख चेतावनी std :: स्ट्रिंग की लंबाई है, अब स्ट्रिंग में वर्णों की संख्या नहीं है।


मैं विंडोज या अन्य जगहों पर std::wstring से बचने की सलाह देता हूं, सिवाय इसके कि जब इंटरफ़ेस द्वारा आवश्यक हो, या विंडोज एपीआई कॉल के पास कहीं भी और सिंटैक्टिक चीनी के रूप में संबंधित एन्कोडिंग रूपांतरण।

मेरा विचार http://utf8everywhere.org में संक्षेप में है जिसमें से मैं सह-लेखक हूं।

जब तक आपका एप्लिकेशन एपीआई-कॉल-केंद्रित नहीं है, उदाहरण के लिए मुख्य रूप से यूआई एप्लीकेशन, सुझाव है कि यूनिकोड स्ट्रिंग्स को std :: स्ट्रिंग में स्टोर करें और यूटीएफ -8 में एन्कोड किया जाए, एपीआई कॉल के पास रूपांतरण कर रहे हों। लेख में उल्लिखित लाभ रूपांतरण की स्पष्ट परेशानी से अधिक हैं, खासकर जटिल अनुप्रयोगों में। बहु-मंच और पुस्तकालय विकास के लिए यह दोगुना है।

और अब, अपने सवालों का जवाब दें:

  1. कुछ कमजोर कारण हैं। यह ऐतिहासिक कारणों के लिए मौजूद है, जहां वाइडचार्स यूनिकोड का समर्थन करने का उचित तरीका माना जाता था। अब यह एपीआई इंटरफेस करने के लिए प्रयोग किया जाता है जो यूटीएफ -16 तारों को पसंद करते हैं। मैं केवल उन एपीआई कॉल के प्रत्यक्ष आसपास के क्षेत्र में उनका उपयोग करता हूं।
  2. इसमें std :: स्ट्रिंग के साथ कुछ लेना देना नहीं है। यह आपके द्वारा डाले गए एन्कोडिंग को पकड़ सकता है। एकमात्र सवाल यह है कि आप इसकी सामग्री का इलाज कैसे करते हैं। मेरी सिफारिश यूटीएफ -8 है, इसलिए यह सभी यूनिकोड वर्णों को सही ढंग से पकड़ पाएगा। यह लिनक्स पर एक आम प्रथा है, लेकिन मुझे लगता है कि विंडोज प्रोग्राम भी इसे करना चाहिए।
  3. नहीं।
  4. वाइड चरित्र एक भ्रमित नाम है। यूनिकोड के शुरुआती दिनों में, एक धारणा थी कि चरित्र को दो बाइट्स में एन्कोड किया जा सकता है, इसलिए नाम। आज, यह "चरित्र के किसी भी भाग के लिए है जो दो बाइट लंबा है"। यूटीएफ -16 को ऐसे बाइट जोड़े (उर्फ वाइड कैरेक्टर) के अनुक्रम के रूप में देखा जाता है। यूटीएफ -16 में एक चरित्र या तो एक या दो जोड़े लेता है।





wstring