如何拼接带空格分隔的多个BSTR？含多BSTR拼接报错求助

一、修正手写6个BSTR拼接代码的错误 #

你的代码存在索引计算错误和内存分配缺失的问题，直接导致输出为空：

1. 未提前计算总长度并调用SysAllocStringLen分配足够内存
2. 空格的位置索引完全错误（比如result[lengthB] = L' '，此处lengthB是第二个BSTR的长度，并非当前拼接后的偏移位置）
3. 字符串终止符的位置计算错误

修正后的完整代码示例：

BSTR Concatenate6BSTRs(BSTR a, BSTR b, BSTR c, BSTR d, BSTR e, BSTR f)
{
    // 计算每个BSTR的长度
    auto lenA = SysStringLen(a);
    auto lenB = SysStringLen(b);
    auto lenC = SysStringLen(c);
    auto lenD = SysStringLen(d);
    auto lenE = SysStringLen(e);
    auto lenF = SysStringLen(f);

    // 总长度：所有BSTR长度之和 + 5个分隔空格（6个BSTR需要5个空格）
    auto totalLen = lenA + lenB + lenC + lenD + lenE + lenF + 5;
    BSTR result = SysAllocStringLen(NULL, totalLen);
    if (!result) return NULL; // 处理内存分配失败的情况

    OLECHAR* ptr = result;
    // 逐个拷贝BSTR并插入空格
    memcpy(ptr, a, lenA * sizeof(OLECHAR));
    ptr += lenA;
    
    *ptr++ = L' ';
    memcpy(ptr, b, lenB * sizeof(OLECHAR));
    ptr += lenB;
    
    *ptr++ = L' ';
    memcpy(ptr, c, lenC * sizeof(OLECHAR));
    ptr += lenC;
    
    *ptr++ = L' ';
    memcpy(ptr, d, lenD * sizeof(OLECHAR));
    ptr += lenD;
    
    *ptr++ = L' ';
    memcpy(ptr, e, lenE * sizeof(OLECHAR));
    ptr += lenE;
    
    *ptr++ = L' ';
    memcpy(ptr, f, lenF * sizeof(OLECHAR));
    ptr += lenF;

    // 手动添加字符串终止符
    *ptr = L'\0';
    return result;
}

二、通用多BSTR拼接函数（更灵活） #

如果需要拼接任意数量的BSTR，建议实现一个通用函数，支持传入BSTR数组和数量：

BSTR ConcatenateBSTRsWithSpace(const BSTR* bstrs, int count)
{
    if (count <= 0 || !bstrs) return NULL;

    // 计算总长度
    int totalLen = 0;
    for (int i = 0; i < count; ++i)
    {
        totalLen += SysStringLen(bstrs[i]);
    }
    // 加上分隔空格的数量（n个BSTR需要n-1个空格）
    totalLen += (count - 1);

    BSTR result = SysAllocStringLen(NULL, totalLen);
    if (!result) return NULL;

    OLECHAR* ptr = result;
    for (int i = 0; i < count; ++i)
    {
        BSTR current = bstrs[i];
        auto len = SysStringLen(current);
        memcpy(ptr, current, len * sizeof(OLECHAR));
        ptr += len;
        // 最后一个BSTR后不需要加空格
        if (i != count - 1)
        {
            *ptr++ = L' ';
        }
    }
    *ptr = L'\0';
    return result;
}

使用示例：

BSTR bstrs[] = {a, b, c, d, e, f};
BSTR combined = ConcatenateBSTRsWithSpace(bstrs, 6);
// 使用完成后记得调用SysFreeString(combined)释放内存

三、修复_bstr_t的用法问题 #

你使用_bstr_t时丢失值，大概率是所有权管理或初始化错误，正确用法如下：

// 假设a、b、c是已有的有效BSTR
_bstr_t combined(a); // 默认拷贝a的内容，避免所有权冲突
combined += L" ";
combined += b;
combined += L" ";
combined += c;

// 转换为独立BSTR使用（copy()会生成新的BSTR，需手动释放）
BSTR result = combined.copy();
// 使用后调用SysFreeString(result)释放

注意：如果你的BSTR是通过SysAllocString分配的，若不想让_bstr_t接管所有权，初始化时需传入第二个参数：_bstr_t combined(a, false);，此时_bstr_t会拷贝BSTR内容而非接管。

四、改进原有Concatenate2BSTRs支持分隔符 #

若想复用原有双BSTR拼接函数，可修改为支持插入分隔符的版本：

static BSTR Concatenate2BSTRsWithSeparator(BSTR a, BSTR b, const OLECHAR* sep = L" ")
{
    auto lenA = SysStringLen(a);
    auto lenB = SysStringLen(b);
    auto lenSep = SysStringLen(sep);

    auto totalLen = lenA + lenSep + lenB;
    BSTR result = SysAllocStringLen(NULL, totalLen);
    if (!result) return NULL;

    memcpy(result, a, lenA * sizeof(OLECHAR));
    memcpy(result + lenA, sep, lenSep * sizeof(OLECHAR));
    memcpy(result + lenA + lenSep, b, lenB * sizeof(OLECHAR));
    result[totalLen] = L'\0';
    return result;
}

链式拼接多个BSTR的示例：

BSTR temp1 = Concatenate2BSTRsWithSeparator(a, b);
BSTR temp2 = Concatenate2BSTRsWithSeparator(temp1, c);
BSTR temp3 = Concatenate2BSTRsWithSeparator(temp2, d);
// ... 依次拼接后续BSTR
// 注意：每次拼接后需释放临时BSTR
SysFreeString(temp1);
SysFreeString(temp2);
// 最终temp3为拼接结果，使用后释放

内容的提问来源于stack exchange，提问作者Mohamed Noordin