什么是（编辑：MFC）的对象的内部结构CString类？

Question

I need to strncpy() (effectively) from a ( Edit: MFC) CString object to a C string variable. It's well known that strncpy() sometimes fails (depending on the source length **EDIT and the length specified in the call) to terminate the dest C string correctly. To avoid that evil, I'm thinking to store a NUL char inside the CString source object and then to strcpy() or memmove() that guy.

Is this a reasonable way to go about it? If so, what must I manipulate inside the CString object? If not, then what's an alternative that will guarantee a properly-terminated destination C string?

Answer 1

CSimpleStringT::GetString gives a pointer to a null-terminated string. Use this as the soure for strncpy . As this is C++, you should only use C-style strings when interfacing with legacy APIs. Use std::string instead.

Answer 2

I hope they don't changed from when I used them: that was many years ago :)

They used an interesting 'trick' to handle the refcount and the very fast and efficient automatic conversion to char*: ie the pointer is to LPCSTR, but some back byte is reserved to keep the implementation state.

So the struct can be used with the older windows API (LPCSTR without overhead). I found at the time the idea interesting!

Of course the key ìs the availability of allocators: they simply offsets the pointer when mallocing/freeing.

I remember there was a buffer request to (for instance) modify the data available: GetBuffer(0), followed by ReleaseBuffer().

HTH

Answer 3

strncpy() only "fails" to null-terminate the destination string when the source string is longer than the length limit you specify. You can ensure that the destination is null-terminated by setting its last character to null yourself. For example:

#define DEST_STR_LEN 10

char dest_str[DEST_STR_LEN + 1];  // +1 for the null
strncpy(dest_str, src_str, DEST_STR_LEN);
dest_str[DEST_STR_LEN] = '\0';

If src_str is more than DEST_STR_LEN characters long, dest_str will be a properly-terminated string of DEST_STR_LEN characters. If src_str is shorter than that, strncpy() will put a null terminator somewhere within dest_str , so the null at the very end is irrelevant and harmless.

Answer 4

一种替代方法是首先将字符串归零，然后从CString进行强制转换或memcpy。

Answer 5

If you are not compiling with _UNICODE enabled, then you can get a const char * from a CString very easily. Just cast it to an LPCTSTR :

CString myString("stuff");
const char *byteString = (LPCTSTR)myString;

This is guaranteed to be NULL-terminated.

If you have built with _UNICODE , then CString is a UTF-16 encoded string. You can't really do anything directly with that.

If you do need to copy the data from the CString , this very easy, even using C-style code. Just make sure that you allocate sufficient memory and are copying the right length:

CString myString("stuff");
char *outString = (char*)malloc(myString.Length() + 1);
strncpy(outString, (LPCTSTR)myString, myString.Length());

Answer 6

CString ends with NULL so as long as your text is correct (no NULL characters inside) then copying should be safe. You can write:

char szStr[256];
strncpy(szStr, (LPCSTR) String, 3);
szStr[3]='\0'; /// b-cos no null-character is implicitly appended to the end of destination

if you store null somehere inside CString object you will probably cause yourself more problems, CString stores its lenght internally.

Answer 7

Another alternative solution would rather involve support from CPU or compiler, as it's much better approach - simply make sure that when copying memory in "safe" mode, at any time after every atomic operation there is zero added on the end, so when whole loop fails, the destination string will still be terminated, without need to zero it fully before making copy. There could be also support for fast zero - just mark start and stop of zeroed region and it's instantly cleared in RAM, this would make things a lot easier.