फ़ाइल पथ

ऐसा लगता है - सी ++ में फाइलों के साथ काम करने से आसान क्या हो सकता है। लेकिन सबसे खराब दृष्टिकोण को खोजने में लोग अपने संसाधन में हड़ताली हैं।

ऐसा न करें:



std::string filepath("C:\\");

std::ofstream file(filepath.c_str());









संक्षेप में, चार स्ट्रिंग स्ट्रिंग में गैर-एएससीआईआई पात्रों का उपयोग करने से दु: खद परिणाम हो सकते हैं। मैंने इस मुद्दे पर पहले ही एन्कोडिंग के बारे में एक पोस्ट में चर्चा की है। इस मामले में, फ़ाइल का नाम सीधे स्रोत के एन्कोडिंग पर निर्भर करता है, और अगर कोई इसे utf-8 में लिखता है, तो विंडोज़-एक्सपी में आपको निषिद्ध पात्रों के साथ एक फ़ाइल मिल सकती है, जिसके साथ कुछ भी करना असंभव होगा। आप गैर-एएससीआईआई का उपयोग नहीं कर सकते। लेकिन आप इसे उपयोगकर्ता को (एक स्ट्रीम या एक DB जिससे पथ प्राप्त होता है) मना नहीं कर सकते। यह जातीय भेदभाव है! तत्काल सुधार:



std::wstring filepath= L"C:\"

std::ofstream file(filepath.c_str());







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

- "निराला जीसीसी" या "निराला stlport" में ofstream का निर्माण शामिल नहीं है :: ofstream (wchar_t *)

तथ्य यह है कि वर्तमान मानक अपने अस्तित्व का मतलब नहीं है (अभी तक C ++ 0x को स्पर्श न करें)। मुलायम के लिए यह शुद्ध उत्साह है।

क्या करें?

कई विकल्प

• रास्तों के साथ काम करने के लिए एक तीसरे पक्ष के पुस्तकालय का उपयोग करें (उदाहरण के लिए बढ़ावा :: फाइल सिस्टम)
• Std :: locale का प्रयोग करें
• अपना आविष्कार करें

तीसरे विकल्प के साथ, सब कुछ स्पष्ट है, पहले वाले के साथ भी, कुछ भी जटिल नहीं है:

2. #include <boost / filesystem / fstream.hpp>
3. # अलग करें <string>
5. namepace fs = boost :: filesystem ;
7. int main ( int argc, char * argv )
8. {
9. std :: wstring फ़ाइलपथ ( L "C: \ test" ) ;
10. fs : ofstream ( filepath ) ;
11. वापसी 0 ;
12. }

लेकिन दूसरे के बारे में, जो लोग मैटरियल नहीं सीखते हैं, उन्हें समस्या हो सकती है।

Std :: locale का प्रयोग करें

रिट्रीट।

उपयोगकर्ता को परेशान करना: मूल निवासी में उचित स्थानीयकरण समर्थन की कमी के कारण आपको तृतीय-पक्ष एसटीएल कार्यान्वयन (उदाहरण के लिए stlport) का उपयोग करना होगा। विशेष रूप से, std :: locale ("") फ़ंक्शन हमेशा std :: locale ("C") देता है, जो भी आपके पास हो सकता है। एक ही stlport में इस तरह की कमी है। मिंगव + स्टालपोर्ट + बूस्ट बनाने के तरीके के बारे में मैंने यहां लिखा है ।



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

2. # किंकर्तव्यविमूढ़ <iostream>
3. # अलग करें <string>
4. # अलग करें <
5. # पता लगाएँ <स्थानीय>
6. # याद <
7. #include "facet / codecvt / codecvt_cp866.hpp"
9. / ** @ संक्षिप्त वर्णन स्थानीयकरण लोक का उपयोग करके विस्तृत स्ट्रिंग को बढ़ाता है
10. @return एक संकुचित स्ट्रिंग या रिक्त संकुचित स्ट्रिंग देता है, जिसमें
11. मामले। यदि कोई त्रुटि होती है * /
12. std :: स्ट्रिंग संकरा ( const std :: wstring & wstr, const std :: locale & loc )
13. {
14. const size_t sz = wstr। लंबाई ( ) ;
15. अगर ( sz == 0 )
16. वापसी std :: string ( ) ;
17. mbstate_t राज्य = 0 ;
18. char * cnext ;
19. const wchar_t * wnext ;
20. const wchar_t * wcstr = wstr। c_str ( ) ;
21. char * बफर = नया char [ sz + 1 ] ;
22. std :: uninitialized_fill ( बफर, बफर + sz + 1 , 0 ) ;
23. typedef std :: codecvt < wchar_t , char , mbstate_t > cvt ;
24. cvt :: परिणाम Res ;
25. res = std :: use_facet < cvt > ( loc ) । बाहर ( स्थिति, wcstr, wcstr + sz, wnext,
26. बफ़र, बफ़र + sz, cnext ) ;
27. std :: string result ( बफर ) ;
28. अगर ( Res == cvt :: त्रुटि )
29. वापसी std :: string ( ) ;
30. वापसी परिणाम ;
31. }
33. / ** @ संक्षिप्त स्थानीयकरण लोक का उपयोग करके स्ट्रिंग का विस्तार करता है
34. @return एक विस्तारित स्ट्रिंग या एक खाली विस्तारित स्ट्रिंग लौटाता है
35. यदि कोई त्रुटि होती है। * /
36. std :: wstring चौड़ी ( const std :: string & str, const std :: locale & loc )
37. {
38. const size_t sz = str। लंबाई ( ) ;
39. अगर ( sz == 0 )
40. वापसी std :: wstring ( ) ;
41. mbstate_t राज्य = 0 ;
42. const char * cnext ;
43. wchar_t * wnext ;
44. const char * cstr = str। c_str ( ) ;
45. wchar_t * बफर = नया wchar_t [ sz + 1 ] ;
46. std :: uninitialized_fill ( बफर, बफर + sz + 1 , 0 ) ;
47. typedef std :: codecvt < wchar_t , char , mbstate_t > cvt ;
48. cvt :: परिणाम Res ;
49. res = std :: use_facet < cvt > ( loc ) । में ( स्थिति, कस्तूरी, कस्तूरी + sz, cnext,
50. बफ़र, बफ़र + sz, wnext ) ;
51. std :: wstring परिणाम ( बफर ) ;
52. हटाना [ ] बफर ;
53. अगर ( Res == cvt :: त्रुटि )
54. वापसी std :: wstring ( ) ;
55. वापसी परिणाम ;
56. }
58. int main ( int argc, char * argv [ ] )
59. {
60. // मान लीजिए कि पथ के साथ एक cp866 फ़ाइल है
61. std :: ofile ofile ( "input.txt" , std :: ios :: बाइनरी ) ;
62. अगर ( ofile )
63. {
64. std :: cerr << "त्रुटि ओपन फ़ाइल" << std :: endl ;
65. वापसी 0 ;
66. }
67. std :: ostreambuf_iterator < char > लेखक ( ofile ) ;
68. * ( लेखक ) = 0x2 ; // टी
69. * ( ++ लेखक ) = 0xa5 ; // ई
70. * ( ++ लेखक ) = 0xe1 ; // एस
71. * ( ++ लेखक ) = 0x2 ; // टी
72. ofile। करीब ( ) ;
74. // पथ पढ़ें
75. std :: locale cp866 ( std :: locale ( ) , new codecvt_cp866 ) ;
76. std :: wifstream ifile ( "input.txt" , std :: ios :: Binary ) ;
77. ifile। imbue ( cp866 ) ;
78. std :: wstring wpath ;
79. ifile >> wpath ;
80. ifile >> wpath ;
81. ifile। करीब ( ) ;
83. // इस पथ के साथ एक फ़ाइल बनाएँ
84. std :: ofstream फ़ाइल ( संकीर्ण ( wpath, std :: locale ( "" ) ) । c_str ( ) ) ;
85. फ़ाइल << "परीक्षण" ;
86. फ़ाइल । करीब ( ) ;
87. }

पहलुओं को git-hub पर लिया जा सकता है।

सारांश

यदि आप argv से पथ का उपयोग करते हैं, तो आप सुरक्षित रूप से इसके साथ काम कर सकते हैं (उपयोगकर्ता जानता है कि वह क्या कर रहा है)। "बाहरी वातावरण" से, एक विस्तृत स्ट्रिंग के रूप में सही ढंग से स्थानीयकृत धारा का उपयोग करके पथ प्राप्त करें और कस्टम स्थानीयकरण का उपयोग करके इसे संकीर्ण करें।



प्रश्नों को संबोधित किया जा सकता है:

0. मानक के लिए

1. स्ट्रेंशेप की पुस्तक (तीसरा विशेष संस्करण, परिशिष्ट)

2. मिंगवॉक प्रलेखन के लिए ।

3. बढ़ावा देने के लिए प्रलेखन के लिए ।

4. पहलुओं और एनकोडिंग के बारे में पोस्ट करने के लिए।



सभी प्रत्यक्ष तरीके!



UPD: खैर, जैसे कि गोरथौरा87 , मिगुन और नारिल ने टिप्पणी में सही ढंग से उल्लेख किया है, बैकस्लैश और प्लेटफ़ॉर्म-विशिष्ट पथ भी एक बुरा विचार है।