如何将矢量转换为<wstring>wchar_t**？

How to convert a vector<wstring> to a wchar_t**?

本文关键字：wstring gt wchar lt 转换      更新时间：2023-10-16

我需要创建一个C兼容（友好）的返回类型，以便我的C++函数可以用于处理基于C的函数。

如何将wstring的矢量转换为wchar_t**数组？

您可以遍历wstring向量，并将每个wstring::c_str()添加到wchart_t**数组中。

尽可能避免这样做要好得多。

如果真的别无选择，你基本上会做一些事情，比如分配一个指针数组，然后为每个字符串分配空间，并将输入中的每个单独字符串复制到你分配的缓冲区。

wchar_t *dupe_string(std::wstring const &input) { 
    wchar_t *ret = new wchar_t[input.size()+1];
    wcscpy(ret, input.c_str());
    return ret;
}
wchar_t **ruin(std::vector<std::wstring> const &input) {
    wchar_t **trash = new wchar_t*[input.size()];
    for (int i=0; i<input.size(); i++)
       trash[i] = dupe_string(input[i]);
    return trash;
}

然而，根据这些评论，我对这适用于当前情况有一些疑虑——这假设输入是宽字符串，通常意味着UTF-16或UTF-32/UCS-4。如果输入真的是UTF-8形式，那么您要处理的存储元素将是char，而不是wchar_t，所以您的输入应该是窄字符串（std::string）和匹配的输出char **，而不是wchar_t **。

wstring是basic_string的模板化实例化，因此其c_str（）函数返回wchar_t*。

所以，你可以做一些类似的事情

std::vector<const wchar_t*> pointers;
pointers.reserve(wstrVec.size());
for (auto it = wstrVec.begin(); it != wstrVec.end(); ++it) {
    pointers.push_back(it->c_str());
}
const whcar_t** cptr = pointers.data();

如果没有更多的上下文，就很难建议处理范围/寿命问题的最佳方式。你是在写一个库（这表明你对作用域没有控制权），还是在为你所监督的C代码的回调提供一个api？

一种常见的方法是提供一个大小调整api，以便调用者可以提供适当大小的目标缓冲区：

size_t howManyWstrings()
{
    return wstrVec.size();
}
bool getWstrings(const wchar_t** into, size_t intoSize /*in pointers*/)
{
    const size_t vecSize = wstrVec.size();
    if (intoSize < vecSize || into == nullptr)
        return false;
    for (size_t i = 0; i < vecSize; ++i) {
        into[i] = wstrVec[i].c_str();
    }
    return true;
}

听起来您的C函数需要一个指向wchar_t缓冲区的指针，并且能够四处移动这个指针。

好吧，这很容易，尽管您必须管理指针的生存期。为此，我建议不要将其作为返回类型（因此让C破坏API，更不用说代码的健全性），而是在C函数的调用位置执行此逻辑：

/** A function that produces your vector */
std::vector<wchar_t> foo();
/** The C function in question */
void theCFunction(wchar_t**);
int main()
{
   std::vector<wchar_t> v = foo();
   wchar_t* ptr = &v[0];
   theCFunction(&ptr);
}

顺便说一句，从问题和一些评论来看，听起来你误解了char和wchar_t是什么—它们位于编码层下方，如果您有UTF-8，那么您应该将UTF-8字符串的每个字节存储为一个字节。这意味着使用char s，就像在std::string中一样。当然，该字符串中的每个单独的字节不一定代表一个逻辑unicode字符，但这不是它的重点

这是用于将向量std::wstring转换为基于wchar_t**的字符串的函数。它也不会因为使用DisposeBuffer（）而泄露任何内存；呼叫不同于其他应答。

wchar_t ** xGramManipulator::GetCConvertedString(vector< wstring> const &input)
{
    DisposeBuffer();  //This is to avoid memory leak for calling this function multiple times
    cStringArraybuffer = new wchar_t*[input.size()]; //cStringArraybuffer is a member variable of type wchar_t**
    for (int i = 0; i < input.size(); i++)
    {
        cStringArraybuffer[i] = new wchar_t[input[i].size()+1];
        wcscpy_s(cStringArraybuffer[i], input[i].size() + 1, input[i].c_str());
        cStringArraySize++;
    }
    return cStringArraybuffer;
}

这是避免内存泄漏的DisposeBuffer Helper函数：

void xGramManipulator::DisposeBuffer(void)
{
    for (size_t i = 0; i < cStringArraySize; i++)
    {
        delete [] cStringArraybuffer[i];
    }
    delete [] cStringArraybuffer;
    cStringArraybuffer = nullptr;
    cStringArraySize = 0;
}

在此之前，在构造函数中分配一个虚拟空间：

xGramManipulator::xGramManipulator()
{
    //allocating dummy array so that when we try to de-allocate it in GetCConvertedString(), dont encounter any undefined behavior
    cStringArraybuffer = new wchar_t*[1];
    cStringArraySize = 0;
    for (int i = 0; i < 1; i++)
    {
        cStringArraybuffer[i] = new wchar_t[1 + 1];
        cStringArraySize++;
    }
}

一切都结束了。

相关文章：