记忆载体 <wchar_t> 从原始内存位置

Question

I'm working with an API that provides, in memory, the memory address and length of strings of interest. I'd like to read these strings into friendlier objects like wstring.

For smaller strings, a statically sized buffer works fine using the following code:

// This code works (but may have other issues)
// _stringLengthOffset and _bufferOffset are provided earlier by the API
// stringOID is the memory location of the string (and in terms of the API, the ObjectID)
DWORD stringLength;
memcpy(&stringLength, ((const void *)(stringOID + _stringLengthOffset)), sizeof(DWORD));
wchar_t argString[DEFAULT_ARGVALUE_BUFFER_SIZE];
memcpy(argString, ((const void *)(stringOID + _bufferOffset)), (stringLength) * sizeof(wchar_t));
argString[stringLength] = L'\0';  // Strings are not null terminated in memory
wstring argumentValue = argString;

I don't think it is a good idea to create a very, very large statically sized buffer (20,000 characters or more are possible with these strings.) I've tried several different approaches and this code seems close but does NOT work.

// This code does NOT work. 
vector<wchar_t> buffer;
buffer.reserve( stringLength + 1 );
memcpy( &buffer[0], (const void *)(stringOID + _bufferOffset), (stringLength) * sizeof(wchar_t) );
buffer.push_back( L'\0' );
buffer.shrink_to_fit();
wstring argumentValue( buffer.begin(), buffer.end() );

Question: If the goal is creating a wstring, how does one correctly copy from raw memory (as provided by this particular API) into a dynamically sized buffer and then create a wstring? ( Apologies if this has been answered before, as it seems like something someone before me would have asked but I was unable to find an appropriate question/answer with a few hours of searching. )

Answer 1

There's a number of ways.

1) Use resize instead of reserve and do the memcpy. also get rid of the shrink fit.

2) Assign directly to the string:

const wchar_t* pstr = reinterpret_cast<const wchar_t*>(stringOID + _bufferOffset);
wstring s(pstr, pstr + stringLength);
// or:
wstring s(pstr, stringLength);

option 2) avoids a copy and additionally initialization of the resized vector.

Answer 2

std::wstring foo (somebuffer, charactercount);

reserve doesn't make a vector x wchar_t's long. it just preallocates. the vector still thinks it has 0 items inside. when you call push_back the vector now contains 1 character. shrink_to_fit will leave it at 1 character. memcpy is unable to tell the vector how long it will be after the copy. I'd recommend using the answer above but if you're hell bent on using a vector, it's resize, not reserve. and don't do the +1. That will be handled in the push_back.