File paths

It would seem - what could be simpler than working with files in C ++. But individuals are astounded in their search for the worst approach.
Do not do this:

std::string filepath("C:\\");
std::ofstream file(filepath.c_str());


In short, the use of non-ASCII characters in char strings can have dire consequences. I have already discussed this issue in a post about encodings . In this case, the file name directly depends on the encoding of the source code and if someone writes something like this in utf-8, in windows-xp you can get a file with forbidden characters, with which nothing can be done. Can not use non-ASCII. But you cannot forbid it to the user (to a flow or a DB from which the way is received). This is discrimination based on nationality! We urgently correct:

std::wstring filepath= L"C:\"
std::ofstream file(filepath.c_str());

Visual Studio users who are ignorant of the standard can calm down until the need forces the compiler to change (more precisely STL). And here it begins ...

- “wacky gcc” or “wacky stlport” does not contain the constructor ofstream :: ofstream (wchar_t *)

The fact is that the current standard does not imply its presence (until we touch C ++ 0x). This is purely small-scale enthusiasm.
')

What to do?

Several options

• Use a third-party library to work with paths (for example, boost :: filesystem)
• Use std :: locale
• Invent your

With the third option, everything is clear, with the first, too, nothing complicated:

2. #include <boost / filesystem / fstream.hpp>
3. #include <string>
5. namespace fs = boost :: filesystem ;
7. int main ( int argc, char * argv )
8. {
9. std :: wstring filepath ( L "C: \ test" ) ;
10. fs :: ofstream ( filepath ) ;
11. return 0 ;
12. }

But over the second, those who did not teach the materiel may have problems.

We use std :: locale

Retreat.
Grieving users mingw: you have to use a third-party STL implementation (for example, stlport) due to the lack of proper localization support in your native language. Or rather, the function std :: locale ("") always returns std :: locale ("C"), whatever you have in it. The same stlport is devoid of such a disadvantage. About how to make a bunch of mingw + stlport + boost, I wrote back here .

All we need to do is follow the simple rules - with non-ASCII, we work in an “extended” way. That is, we read the path to std :: wstring using the appropriately localized stream, and, when used, we narrow down by user localization. This idea is based on the fact that once the user correctly sees the characters of his language in the console, his user localization knows in which encoding it is necessary to narrow a wide string in order to correctly interpret the path. So an example. Suppose we have a file in cp866 encoding containing a path. We need to create a file along this path. What are we doing:

2. #include <iostream>
3. #include <string>
4. #include <fstream>
5. #include <locale>
6. #include <memory>
7. #include "facet / codecvt / codecvt_cp866.hpp"
9. / ** @ brief Narrows a wide string using loc localization
10. @return Returns a narrowed string or an empty narrowed string, in
11. case. if an error occurs * /
12. std :: string narrow ( const std :: wstring & wstr, const std :: locale & loc )
13. {
14. const size_t sz = wstr. length ( ) ;
15. if ( sz == 0 )
16. return std :: string ( ) ;
17. mbstate_t state = 0 ;
18. char * cnext ;
19. const wchar_t * wnext ;
20. const wchar_t * wcstr = wstr. c_str ( ) ;
21. char * buffer = new char [ sz + 1 ] ;
22. std :: uninitialized_fill ( buffer, buffer + sz + 1 , 0 ) ;
23. typedef std :: codecvt < wchar_t , char , mbstate_t > cvt ;
24. cvt :: result res ;
25. res = std :: use_facet < cvt > ( loc ) . out ( state, wcstr, wcstr + sz, wnext,
26. buffer, buffer + sz, cnext ) ;
27. std :: string result ( buffer ) ;
28. if ( res == cvt :: error )
29. return std :: string ( ) ;
30. return result ;
31. }
33. / ** @ brief Extends a string using loc localization
34. @return Returns an extended string or an empty extended string, in
35. if an error occurred. * /
36. std :: wstring widen ( const std :: string & str, const std :: locale & loc )
37. {
38. const size_t sz = str. length ( ) ;
39. if ( sz == 0 )
40. return std :: wstring ( ) ;
41. mbstate_t state = 0 ;
42. const char * cnext ;
43. wchar_t * wnext ;
44. const char * cstr = str. c_str ( ) ;
45. wchar_t * buffer = new wchar_t [ sz + 1 ] ;
46. std :: uninitialized_fill ( buffer, buffer + sz + 1 , 0 ) ;
47. typedef std :: codecvt < wchar_t , char , mbstate_t > cvt ;
48. cvt :: result res ;
49. res = std :: use_facet < cvt > ( loc ) . in ( state, cstr, cstr + sz, cnext,
50. buffer, buffer + sz, wnext ) ;
51. std :: wstring result ( buffer ) ;
52. delete [ ] buffer ;
53. if ( res == cvt :: error )
54. return std :: wstring ( ) ;
55. return result ;
56. }
58. int main ( int argc, char * argv [ ] )
59. {
60. // Let there be a cp866 file with a path
61. std :: ofstream ofile ( "input.txt" , std :: ios :: binary ) ;
62. if ( ! ofile )
63. {
64. std :: cerr << "Error open file" << std :: endl ;
65. return 0 ;
66. }
67. std :: ostreambuf_iterator < char > writer ( ofile ) ;
68. * ( writer ) = 0xe2 ; // t
69. * ( ++ writer ) = 0xa5 ; // e
70. * ( ++ writer ) = 0xe1 ; // with
71. * ( ++ writer ) = 0xe2 ; // t
72. ofile. close ( ) ;
74. // Read the path
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. close ( ) ;
83. // Create a file in this path
84. std :: ofstream file ( narrow ( wpath, std :: locale ( "" ) ) . c_str ( ) ) ;
85. file << "testing" ;
86. file . close ( ) ;
87. }

Facets can be taken on git-hub .

SUMMARY

If you use the path from argv, feel free to work with it (the user knows what he is doing). From the “external environment”, get a path using a properly localized stream as a wide string and narrow it down using custom localization.

Questions can be addressed:
0. To standard
1. To the book of Straustrup (3rd special edition, annex)
2. To the documentation for mingw .
3. To documentation on boost .
4. To post about facets and encodings .

All direct ways!

UPD: Well, as Gorthauer87 , Migun and naryl correctly noted in the comments, backslashes and platform-specific paths are also a bad idea.