将std :: string转换为LPCSTR，尾随或前导'\\ 0'

Question

How can I convert std::string to LPCSTR while preserving '\\0' characters?

I want to use the result on OPENFILENAME.lpstrFilter which requires the filter to contain '\\0' as delimiters.

std::string.c_str() seems to strip and trim '\\0'

Thanks in advance!

==========================

(How do I properly add a comment to the responses like a reply post in a forum?)

After reading your comments, I went on to double check this snippet:

std::string filter = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0";
const char* f1 = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0";
const char* f2 = filter.c_str();
for(int i = 0; i < 50; i++)
{
 char c1 = *(f1 + i); // works
 char c2 = *(f2 + i); // doesn't work. beyond the first \0, it's garbage.
}

Am I mistaken on how c_str() or LPCSTR works?

Answer 1

C_STR doesn't strip the NUL characters. The error is likely in the way you are constructing the STD::string.

Answer 2

Generally speaking, std::string handles embedded '\\0' characters correctly.

However, when interfacing with const char*, extreme care must be taken.

In this case, the problem already occurs during constructing the string with:

std::string filter = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0"; // wrong

Here you construct a std::string from a const char*. As the constructor doesn't know how many characters to use for constructing the std::string, it stops at the first '\\0'.

One could copy the characters one by one oneself, but there is a better way: use the contructor that requires two iterators to the char array, one with the begin and one with the end:

const char filter_[] = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0"; 
std::string filter(filter_, filter_ + sizeof(filter_));

It looks horrible, but hopefully you won't do this that frequently in your code.

Update: Or with appropiate definitions of begin() and end() templates (as per James Kanze's comment):

const char filter_[] = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0"; 
std::string filter(begin(filter_), end(filter_));

Answer 3

The length() of your string is what you need to use to ensure all characters are included, provided it was properly constructed in the first place to include the embedded \\0 characters.

For an LPCSTR valid while cString is in scope:

#include <boost/scoped_array.hpp>
#include <string>
#include <algorithm>

string source("mystring");
boost::scoped_array<char> cString(new char[source.length() + 1]);

std::copy(source.begin(), source.end(), cString.get());
cString[source.length()] = 0;

LPCSTR rawStr = cString.get();

Without scoped_array:

#include <string>
#include <algorithm>

string source("mystring");
LPSTR rawStr = new char[source.length() + 1];

std::copy(source.begin(), source.end(), rawStr);
rawStr[source.length()] = 0;

// do the work here

delete[] rawStr;

EDIT: In your filter init, the constructor of string only includes data up to the first \\0 char. This makes sense - how else would it not to stop copying data when all it has in hand is const char * ? Try this with:

const char f3[] = "Terrain Configuration (*.tcfg)\0*.tcfg\0\0";
std::string filter(f3, sizeof(f3));

Answer 4

It depends on further life-cycle of std::string.

For example you can append terminal zero manually:

std::string test("init");
test += '\0';

This causes length to be increased by one. Or just create another instance of std::string with zero appended