भाषाई और सांस्कृतिक विशेषताओं के बारे में मत भूलना

जल्दी या बाद में, हर किसी को कार्यक्रम लिखते समय भाषाई और सांस्कृतिक विविधता से जुड़ी समस्याओं का सामना करना पड़ता है। मुझे यह जानकर बहुत आश्चर्य हुआ कि मेरे कुछ मित्र जो C ++ में लिखते हैं, अपनी बाइक से इन समस्याओं को हल करते हैं। उन लोगों के लिए जो अभी भी नहीं जानते हैं कि std :: locale क्या है, मैं संक्षेप में बताना चाहता हूं कि इसके साथ कैसे काम करना है और अगर आप इसके बारे में भूल जाते हैं तो क्या होता है ...



std :: locale (स्थानीयकरण) एक ऐसी वस्तु है जो आपको उपयोगकर्ताओं की सांस्कृतिक और भाषाई विशेषताओं को ध्यान में रखने की अनुमति देती है। वास्तव में, यह विशेष वर्गों - पहलुओं का एक कंटेनर है, जो कार्यक्रम तक पहुंचता है अगर उसे प्राकृतिक भाषा पर निर्भर करने वाले कार्यों को करने की आवश्यकता होती है। कार्यक्रम ऐसे कार्यों को स्थानीयकरण के पहलुओं के लिए निर्देश देता है। किसी भी कस्टम पहलुओं को स्थानीयकरण में जोड़ा जा सकता है। लेकिन मानक सबसे अधिक रुचि रखते हैं, क्योंकि वे किसी भी स्थानीयकरण में लागू होते हैं और स्थायी रूप से या अस्थायी रूप से प्रतिस्थापित किए जा सकते हैं:

• टकराना (स्ट्रिंग तुलना)
• संख्यात्मक (संख्याओं का इनपुट / आउटपुट)
• मौद्रिक (पैसे की जमा / निकासी)
• समय (समय इनपुट / आउटपुट)
• ctype (वर्ण वर्गीकरण)
• संदेश (संदेश चयन)

हकीकत में, हम लगातार बिना शक के भी पहलुओं का इस्तेमाल करते हैं। मानक टेम्पलेट लाइब्रेरी इनपुट / आउटपुट के लिए स्थानीयकरण का उपयोग करता है। बढ़ावा :: चरित्र मामले रूपांतरण के लिए regex, आदि। प्लेटफ़ॉर्म द्वारा स्थानीयकरण को परिभाषित किया गया है। * Nix सिस्टम के उपयोगकर्ता "ru_RU: UTF-8", "en_US.UTF-8" जैसी पंक्तियों से परिचित हैं - ये मंच में स्थानीयकरणों के नाम हैं। कार्यक्रम उपयोगकर्ता स्थानीयकरण का उपयोग करता है। यदि स्थानीयकरण उपयोगकर्ता द्वारा निर्दिष्ट नहीं है, तो "क्लासिक" का उपयोग किया जाता है।

पहलू स्थानीयकरण और ओवरराइडिंग का उपयोग करने का एक उदाहरण

एक उदाहरण पर विचार करें जिसमें हम मानक स्थानीयकरण पहलू को बदलने की तकनीक का प्रयास करते हैं। आमतौर पर स्ट्रीमिंग इनपुट / आउटपुट पर विचार करें, लेकिन मैं इस बात पर ध्यान केंद्रित करना चाहूंगा कि क्या हो सकता है यदि आप कोड लिखते हैं जो स्थानीयकरण पर निर्भर करता है, न कि यह जानना कि यह क्या है। आइए लोकप्रिय बढ़ावा के साथ स्थानों का उपयोग करने का प्रयास करें: xpressive पुस्तकालय (आप भी बढ़ावा :: regex का उपयोग कर सकते हैं, लेकिन जो लोग पहली बार xpressive के बारे में सुनते हैं, उनके लिए यह पढ़ने के लिए उपयोगी होगा):

2. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
3. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
5. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
6. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
8. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
9. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
   
   
   
   
10. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
11. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
12. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
13. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
14. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
15. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
16. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
17. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    
18. #include <boost/xpressive/xpressive.hpp> #include <iostream> using namespace std ; using namespace boost :: xpressive ; int main ( int argc, char * argv [ ] ) { sregex xpr = sregex :: compile ( "" , regex_constants :: icase ) ; smatch match ; string str ( " !" ) ; if ( regex_search ( str, match, xpr ) ) cout << "icase ok" << endl ; else cout << "icase fail" << endl ; return 0 ; }
    
    
    
    

यह कुछ को आश्चर्यचकित करेगा कि एक कार्यक्रम का वितरण अत्यधिक मंच पर निर्भर है । इसके अलावा, एक मंच पर, कार्यक्रम विभिन्न परिणाम उत्पन्न कर सकता है। यह सब लोकेल के बारे में है। यदि हम मानते हैं कि उदाहरण फ़ाइल का एन्कोडिंग विंडोज़ -1251 है, तो "आइकस फेल" का परिणाम एक प्लेटफ़ॉर्म पर प्राप्त किया जा सकता है जिसमें उपयोगकर्ता लोकेल को cp1251 के अलावा एन्कोडिंग है। इस तरह के एक मंच का सबसे आम उदाहरण mingw है (एक स्रोत बाइनरी के रूप में डाउनलोड किया गया है) + विंडोज। इस मामले में, बढ़ावा :: xpressive एल्गोरिदम बस पता नहीं है कि cp-1251 कोड तालिका के विस्तारित हिस्से में कौन से अक्षर हैं। और शास्त्रीय स्थानीयकरण का ctype facet इसके लिए दोषी है। Xpressive के साथ काम करने वाले स्थानीयकरण के सही ctype पहलू की रिपोर्ट करके, हम वांछित परिणाम प्राप्त करेंगे। सरलतम मामले में, यदि सिस्टम में वांछित स्थानीयकरण स्थापित किया गया है, तो हमें इसे वैश्विक बनाने की आवश्यकता है

2. // वैश्विक स्थानीयकरण सेट करें
3. std :: locale cp1251_locale ( "ru_RU.CP1251" ) ;
4. std :: locale :: Global ( cp1251_locale ) ;

या इसे रेगेक्स कंपाइलर को रिपोर्ट करें

2. std :: locale cp1251_locale ( "ru_RU.CP1251" ) ;
3. sregex_compiler संकलक ;
4. // रेगेक्स कंपाइलर को बताएं कि किस स्थानीयकरण का उपयोग करना है
5. संकलक। imbue ( cp1251_locale ) ;
6. sregex xpr = संकलक। संकलन ( "दुनिया" , regex_constants :: icase ) ;

सबकुछ ठीक होगा, लेकिन एक ऐसे मंच पर जहां स्थानीयकरण ru_RU समर्थित नहीं है: CP1251 हमारा कोड एक अपवाद फेंक देगा। सबसे अच्छे मामले में, नाम गलत रूप से इंगित किया गया है, सबसे खराब में - आवश्यक स्थानीयकरण सिस्टम में नहीं है। हम अपने स्वयं के ctype facet को लागू करके इस समस्या को हल करेंगे (यह वह है जो xpressive को समझाएगा कि कौन से अक्षर अक्षर हैं और मामला कैसे बदल रहा है)।



CP1251 एन्कोडिंग के लिए ctype facet कार्यान्वयन और उदाहरण का सबसे सरल उदाहरण:

2. #include <बढ़ावा / xpressive / xpressive.hpp>
3. # किंकर्तव्यविमूढ़ <iostream>
5. नाम स्थान std का उपयोग करना ;
6. नाम स्थान को बढ़ावा देने का उपयोग :: xpressive ;
8. / ** @ संक्षिप्त विवरण के साथ सही ढंग से काम करने के लिए ctype पहलू का एक बहुत ही सरल उदाहरण
9. * एन्कोडेड Cp1251 * /
10. वर्ग ctype_cp1251 : सार्वजनिक ctype < char >
11. {
12. जनता :
14. ctype_base में / ** @ breif मास्क सभी संभव प्रकारों का एक गणन है
15. * वर्ण - अल्फा, अंक, ... * /
16. typedef टाइपनेम ctype < char > :: ctype_base :: मास्क मास्क ;
18. // संक्षिप्तता के लिए, स्थिरांक को फिर से परिभाषित करें
19. एनम {
20. अल्फा = ctype < char > :: अल्फा ,
21. निचला = ctype < char > :: निचला ,
22. punct = ctype < char > :: punct
23. // अन्य मास्क
24. } ;
26. / ** @ संक्षिप्त मुख्य निर्माता। r - जीवन के क्षेत्र को दर्शाता है
27. * पहलू। अधिक जानकारी के लिए स्ट्रैसपुप द्वारा पुस्तक देखें। * /
28. ctype_cp1251 ( size_t r = 0 )
29. {
30. // मास्क टेबल को इनिशियलाइज़ करें। सूचकांक चार का नकारात्मक हिस्सा है।
31. // अर्थात, ext_tab [1] चार के लिए मुखौटा है (-1) - 'i'
32. ext_tab [ 0 ] = 0 ;
33. for ( size_t i = 1 ; i <= 32 ; ++ i )
34. ext_tab [ i ] = अल्फा | कम ;
35. for ( size_t i = 33 ; मैं <= 64 ; ++ i )
36. ext_tab [ i ] = अल्फा | ऊपरी ;
37. // ... इस उदाहरण में अन्य वर्ण दिलचस्प नहीं हैं
38. for ( size_t i = 65 ; मैं <= 128 ; ++ i )
39. ext_tab [ i ] = punct ;
40. }
42. ~ ctype_cp1251 ( )
43. { }
45. संरक्षित :
47. / ** @ संक्षिप्त प्रश्न का उत्तर देता है कि क्या चरित्र c, m * / से मेल खाता है
48. वर्चुअल बूल है ( मास्क एम, चार सी ) कास्ट
49. {
50. अगर ( 0 <= c && c <= 127 )
51. वापसी ctype < char > :: is ( m, c ) ;
52. और यदि ( - 128 <= c && c < 0 )
53. वापसी ext_tab [ static_cast < size_t > ( c * - 1 ) ] & m ;
54. }
56. / ** @ संक्षिप्त धर्मान्तरित ग
57. वर्चुअल चार do_toupper ( चार सी ) कास्ट
58. {
59. अगर ( 0 <= c && c <= 127 )
60. वापसी ctype < char > :: do_toupper ( c ) ;
61. और यदि ( ( कम है, ग ) )
62. वापसी c - 32 ;
63. वापसी c ;
64. }
66. / ** @ संक्षिप्त चरित्र को c को नीचे करने के लिए परिवर्तित करता है * /
67. वर्चुअल चार do_tolower ( चार सी ) कास्ट
68. {
69. अगर ( 0 <= c && c <= 127 )
70. वापसी ctype < char > :: do_tolower ( c ) ;
71. और यदि ( ( ऊपरी, सी ) )
72. वापसी c + 32 ;
73. वापसी c ;
74. }
76. // इसलिए उदाहरण को जटिल नहीं करने के लिए, हम बाकी को फिर से परिभाषित नहीं करेंगे
77. // आभासी कार्य
79. निजी :
80. // नकल पर रोक
81. ctype_cp1251 ( const ctype_cp1251 & ) ;
82. const ctype_cp1251 और ऑपरेटर = ( const ctype_cp1251 & ) ;
83. मास्क ext_tab [ 129 ] ; // @ <कोड तालिका CP1251 के विस्तारित भाग के मुखौटे
84. } ;
86. int main ( int argc, char * argv [ ] )
87. {
88. // पहलू का एक उदाहरण बनाएँ
89. ctype < char > * ctype_cp1251_facet = new ctype_cp1251 ( ) ;
91. // वर्तमान एक के आधार पर एक नया स्थानीयकरण बनाएं, का उपयोग करके
92. // मुखर परिभाषित। वैश्विक परिभाषित कर सकते हैं
93. // वर्णित पहलू के साथ स्थानीयकरण, फिर सभी वर्ग और
94. // फ़ंक्शन, वे इसका उपयोग करेंगे।
95. लोकेल cp1251_locale ( लोकेल ( "" ) , ctype_cp1251_facet ) ;
97. // विशिष्ट स्थानीयकरण के साथ एक रेगेक्स कंपाइलर बनाएं
98. sregex_compiler संकलक ;
99. संकलक। imbue ( cp1251_locale ) ;
101. sregex xpr = संकलक। संकलन ( "दुनिया" , regex_constants :: icase ) ;
102. स्मैश मैच ;
103. स्ट्रिंग स्ट्र ( "हेलो पेसिक!" ) ;
104. अगर ( regex_search ( str, match, xpr ) )
105. cout << "icase ok" << endl ;
106. अन्यथा
107. cout << "icase fail" << endl ;
108. वापसी 0 ;
109. }

अब कार्यक्रम का परिणाम एक विशिष्ट मंच पर निर्भर नहीं करेगा। मानक पहलुओं को फिर से परिभाषित करने या नए लोगों को जोड़कर, आप उपयोगकर्ताओं की सांस्कृतिक और भाषाई विशेषताओं के आधार पर एल्गोरिथ्म / कार्यक्रम के व्यवहार को नियंत्रित कर सकते हैं।



एसटीडी का पूरा विवरण :: स्थानीय वर्ग और पहलू उपयोग तकनीकों को ब्योर्न स्ट्रॉन्गअप की पुस्तक "सी ++ प्रोग्रामिंग लैंग्वेज" के तीसरे विशेष संस्करण में, परिशिष्ट में पाया जा सकता है। आप मुख्‍य संरचना को स्‍पष्‍ट करने के लिए किसी भी एसटीएल मैनुअल का उपयोग कर सकते हैं। उदाहरण के लिए यहाँ ।



एन्कोडिंग रूपांतरण के कार्य को कोडेकावेट पहलू को लागू करके हल किया जाता है। अगर यह दिलचस्प है, तो मैं इसके बारे में अगले लेख में बताऊंगा।



______________________

पाठ को Blog Editor में © SoftCoder.ru द्वारा तैयार किया गया है