Safe C++ std::string to TCHAR * conversion?

Question

I am trying to convert a std::string to a TCHAR* for use in CreateFile() . The code i have compiles, and works, but Visual Studio 2013 comes up with a compiler warning:

warning C4996: 'std::_Copy_impl': Function call with parameters that may be unsafe - this call relies on the caller to check that the passed values are correct. To disable this warning, use -D_SCL_SECURE_NO_WARNINGS. See documentation on how to use Visual C++ 'Checked Iterators'

I understand why i get the warning, as in my code i use std::copy, but I don't want to define D_SCL_SECURE_NO_WARNINGS if at all possible, as they have a point: std::copy is unsafe/unsecure. As a result, I'd like to find a way that doesn't throw this warning.

The code that produces the warning:

std::string filename = fileList->getFullPath(index);
TCHAR *t_filename = new TCHAR[filename.size() + 1];
t_filename[filename.size()] = 0;
std::copy(filename.begin(), filename.end(), t_filename);
audioreader.setFile(t_filename);

audioreader.setfile() calls CreateFile() internally, which is why i need to convert the string.

fileList and audioreader are instances of classes i wrote myself, but I'd rather not change the core implementation of either if at all possible, as it would mean I'd need to change a lot of implementation in other areas of my program, where this conversion only happens in that piece of code. The method I used to convert there was found in a solution i found at http://www.cplusplus.com/forum/general/12245/#msg58523

I've seen something similar in another question ( Converting string to tchar in VC++ ) but i can't quite fathom how to adapt the answer to work with mine as the size of the string isn't constant. All other ways I've seen involve a straight (TCHAR *) cast (or something equally unsafe), which as far as i know about the way TCHAR and other windows string types are defined, is relatively risky as TCHAR could be single byte or multibyte characters depending on UNICODE definition.

Does anyone know a safe, reliable way to convert a std::string to a TCHAR* for use in functions like CreateFile() ?

EDIT to address questions in the comments and answers:

Regarding UNICODE being defined or not: The project in VS2013 is a win32 console application, with #undef UNICODE at the top of the .cpp file containing main() - what is the difference between UNICODE and _UNICODE ? as i assume the underscore in what Amadeus was asking is significant.

Not directly related to the question but may add perspective: This program is not going to be used outside the UK, so ANSI vs UNICODE does not matter for this. This is part of a personal project to create an audio server and client. As a result you may see some bits referencing network communication. The aim of this program is to get me using Xaudio and winsock. The conversion issue purely deals with the loading of the file on the server-side so it can open it and start reading chunks to transmit. I'm testing with .wav files found in c:/windows/media

Filename encoding: I read the filenames in at runtime by using FindFirstFileA() and FindNextFileA() . The names are retrieved by looking at cFilename in a WIN32_FIND_DATAA structure. They are stored in a vector<string> (wrapped in a unique_ptr if that matters) but that could be changed. I assume this is what Dan Korn means.

More info about the my classes and functions:

The following are spread between AudioReader.h, Audioreader.cpp, FileList.h, FileList.cpp and ClientSession.h. The fragment above is in ClientSession.cpp. Note that in most of my files i declare using namespace std;

shared_ptr<FileList> fileList; //ClientSession.h
AudioReader audioreader; //ClientSession.h

string _storedpath; //FileList.h
unique_ptr<vector<string>> _filenames; //FileList.h

//FileList.cpp
string FileList::getFullPath(int i)
{
string ret = "";
unique_lock<mutex> listLock(listmtx);
    if (static_cast<size_t>(i) < _count)
    {
        ret = _storedpath + _filenames->at(i);
    }
    else
    {
        //rather than go out of bounds, return the last element, as returning an error over the network is difficult at present
        ret = _storedpath + _filenames->at(_count - 1);
    }
return ret;
}

unique_ptr<AudioReader_Impl> audioReaderImpl; //AudioReader.h

//AudioReader.cpp
HRESULT AudioReader::setFile(TCHAR * fileName)
{
    return audioReaderImpl->setFile(fileName);
}

HANDLE AudioReader_Impl::fileHandle; //AudioReader.cpp
//AudioReader.cpp
HRESULT AudioReader_Impl::setFile(TCHAR * fileName)
{
    fileHandle = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
    if (fileHandle == INVALID_HANDLE_VALUE)
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
    if (SetFilePointer(fileHandle, 0, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
    return S_OK;
}

Answer 1

The root of your problem is that you are mixing TCHAR s and non- TCHAR s. Even if you get it to work on your machine, unless you do it precisely right, it will fail when non-ASCII characters are used in the path.

If you can use std::tstring instead of regular string, then you won't have to worry about format conversions or codepage versus Unicode issues.

If not, you can use conversion functions like MultiByteToWideChar but make sure you understand the encoding used in the source string or it will just make things worse.

Answer 2

If you do not need to support the string containing UTF-8 (or another multi-byte encoding) then simply use the ANSI version of Windows API:

handle = CreateFileA( filename.c_str(), .......)

You might need to rejig your code for this as you have the CreateFile buried in a function that expects TCHAR . That's not advised these days; it's a pain to splatter T versions of everything all over your code and it has flow-on effects (such as std::tstring that someone suggested - ugh!)

There hasn't been any need to support dual compilation from the same source code since about 1998. Windows API has to support both versions for backward compatibility but your own code does not have to.

---

If you do want to support the string containing UTF-8 (and this is a better idea than using UTF-16 everywhere ) then you will need to convert it to a UTF-16 string in order to call the Windows API.

The usual way to do this is via the Windows API function MultiByteToWideChar which is a bit awkward to use correctly, but you could wrap it up in a function:

std::wstring make_wstring( std::string const &s );

that invokes MultiByteToWideChar to return a UTF-16 string that you can then pass to WinAPI functions by using its .c_str() function.

See this codereview thread for a possible implementation of such a function (although note discussion in the answers)

Answer 3

Try this instead:

std::string filename = fileList->getFullPath(index);

#ifndef UNICODE
audioreader.setFile(filename.c_str());
#else
std::wstring w_filename;
int len = MultiByteToWideChar(CP_ACP, 0, filename.c_str(), filename.length(), NULL, 0);
if (len > 0)
{
    w_filename.resize(len);
    MultiByteToWideChar(CP_ACP, 0, filename.c_str(), filename.length(), &w_filename[0], len);
}
audioreader.setFile(w_filename.c_str());
#endif

Alternatively:

std::string filename = fileList->getFullPath(index);

#ifndef UNICODE
audioreader.setFile(filename.c_str());
#else
std::wstring_convert<std::codecvt<wchar_t, char, std::mbstate_t>> conv;
std::wstring w_filename = conv.from_bytes(filename);
audioreader.setFile(w_filename.c_str());
#endif