如何从dll中获取没有垃圾的字符串？

Question

I'd like to get a string from dll in the VB so I've made some code as the below,

#include <windows.h> 
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <tchar.h>
#include <atlconv.h>
#include <atlcoll.h>  
#include <assert.h> 
#include <atlbase.h> 

using namespace std;

double _stdcall pll_dll(double* datain0, double* datain1, double* dataout0, double* dataout1, BSTR * str, int* str_len)
{
    char buff[128];
    char * str0;
    char str1[128];


    *dataout0 = *datain0 + 20;
    *dataout1 = *datain1 + 30;

    *str_len =  30;

    str0 = " Nice ";
    sprintf(buff, "Hi  %s  \n", str0);
    strcpy(str1, buff);

    char* p = str1;
    SysReAllocString(str, (OLECHAR*)p);



    return 0;
}

But especially, in this case, when I prove the s, I've got a string with garbage data as the below.

So how can I get a string without this garbage data?

: s : Hi Nice 儆儆儆儆儆儆儆儆좄* : String

Answer 1

You are misusing SysReAllocString() .

Your buffers are uninitialized when declared, so they initially contain whatever random bytes already existed on the stack. sprintf() and strcpy() then populate the buffers with valid 8-bit data and null terminate them, which is fine when working with 8-bit strings. But they don't overwrite any memory past the null terminators, so there is still random bytes located there.

You are then giving the final 8-bit string data as-is to SysReAllocString() , using a simple typecast of a char* pointer to a wchar_t* pointer to keep the compiler happy. But you are still pointing at 8-bit data. SysReAllocString() expects a proper 16-bit Unicode string instead, including a 16-bit null teminator. Since you only have an 8-bit null terminator, the function ends up copying past your null terminator into surrounding memory.

If you get rid of the typecast, the code would fail to compile, and for good reason. Don't use typecasts to avoid compiler errors.

Pre-initializing the buffers with zeros will only mask the problem, by ensuring there are consecutive null bytes in the final buffer that can act as a Unicode null terminator when interpreted as 16-bit data. But you are still storing 8-bit character data in the buffers to begin with.

To properly fix this, you must convert your output string data to Unicode before you can then create a BSTR from it.

You need to either:

• use MultiByteToWideChar() to convert your final char data to wchar_t .

   double _stdcall pll_dll(double* datain0, double* datain1, double* dataout0, double* dataout1, BSTR * str, int* str_len) { char c_buff[128] = {0}; wchar_t w_buff[128] = {0}; char * str0; int len; *dataout0 = *datain0 + 20; *dataout1 = *datain1 + 30; *str_len = 30; str0 = " Nice "; len = sprintf(c_buff, "Hi %s \\n", str0); len = MultiByteToWideChar(CP_ACP, 0, c_buff, len, w_buff, 128); SysReAllocStringLen(str, w_buff, len); return 0; } 

• rewrite the code to use swprintf() instead of sprintf() .

   double _stdcall pll_dll(double* datain0, double* datain1, double* dataout0, double* dataout1, BSTR * str, int* str_len) { wchar_t buff[128] = {0}; wchar_t * str0; int len; *dataout0 = *datain0 + 20; *dataout1 = *datain1 + 30; *str_len = 30; str0 = L" Nice "; len = swprintf(buff, L"Hi %s \\n", str0); SysReAllocStringLen(str, buff, len); return 0; }