std::向量转换为 char* 数组

Question

我有一个 std::vector，我需要将其用于读取 char* foo 的 C 函数参数。我见过如何将 std::string 转换为 char*。作为 C++ 的新手，我正在尝试拼凑如何对向量的每个元素执行此转换并生成 char* 数组。

我见过几个密切相关的 SO 问题，但大多数似乎都说明了走向另一个方向并创建 std::vector 的方法。

Answer 1

您可以使用 std::transform 作为：

std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);  

这需要您将 convert() 实现为：

char *convert(const std::string & s)
{
   char *pc = new char[s.size()+1];
   std::strcpy(pc, s.c_str());
   return pc; 
}

---

测试代码：

int main() {
       std::vector<std::string>  vs;
       vs.push_back("std::string");
       vs.push_back("std::vector<std::string>");
       vs.push_back("char*");
       vs.push_back("std::vector<char*>");
       std::vector<char*>  vc;

       std::transform(vs.begin(), vs.end(), std::back_inserter(vc), convert);   

       for ( size_t i = 0 ; i < vc.size() ; i++ )
            std::cout << vc[i] << std::endl;

       for ( size_t i = 0 ; i < vc.size() ; i++ )
            delete [] vc[i];
}

输出：

std::string
std::vector<std::string>
char*
std::vector<char*>

在线演示： http://ideone.com/U6QZ5

您可以在任何需要 char** 的地方使用 &vc[0]。

请注意，由于我们使用 new 为每个 std::string 分配内存（在 convert 函数中），因此我们必须取消分配记忆在最后。这使您可以灵活地更改向量 vs；您可以向其中 push_back 更多字符串，从 vs 和 vc 中删除现有字符串（即 vector< /code> 仍然有效！

但是如果您不想要这种灵活性，那么您可以使用这个 convert 函数：

const char *convert(const std::string & s)
{
   return s.c_str();
}

并且您必须更改 std::vector; 到std::vector。

现在，在转换之后，如果您通过插入新字符串或从中删除旧字符串来更改 vs，则所有内容vc 中的 char* 可能会变得无效，这是另一个重要的一点，您不需要使用 delete vc[i]。 在你的代码中了。

Answer 2

您能做的最好的事情就是分配一个与您的向量大小相同的 const char* 的 std::vector 。然后，遍历向量的每个元素，调用 c_str() 来获取字符串数组并将其存储为数组的相应元素。然后，您可以将该向量的第一个元素的指针传递给相关函数。

代码如下所示：

std::vector<const char *> cStrArray;
cStrArray.reserve(origVector.size());
for(int index = 0; index < origVector.size(); ++index)
{
  cStrArray.push_back(origVector[index].c_str());
}

//NO RESIZING OF origVector!!!!

SomeCFunction(&cStrArray[0], cStrArray.size());

请注意，您不能允许在从 std 获取 const char* 之间调整原始字符串向量的大小::strings，以及调用 C 函数的时间。

Answer 3

这应该有效：

char ** arr = new char*[vec.size()];
for(size_t i = 0; i < vec.size(); i++){
    arr[i] = new char[vec[i].size() + 1];
    strcpy(arr[i], vec[i].c_str());
}

编辑：

假设 vec 仍然具有正确数量的元素，以下是释放这些数据结构的方法，如果您的 C 函数以某种方式修改了该数组，您可能需要以另一种方式获取大小。

for(size_t i = 0; i < vec.size(); i++){
    delete [] arr[i];
}
delete [] arr;

再次编辑：

如果您的 C 函数不修改字符串，则可能不需要复制字符串。如果您能详细说明您的界面是什么样子，我相信我们可以为您提供更好的帮助。

Answer 4

C++0x 解决方案，其中 std::string 的元素保证连续存储：

std::vector<std::string> strings = /* from somewhere */;
int nterms = /* from somewhere */;

// using std::transform is a possibility depending on what you want
// to do with the result of the call
std::for_each(strings.begin(), string.end(), [nterms](std::string& s)
{ ModelInitialize(&s[0], nterms); }

如果函数 null 终止其参数，则在调用 (s.begin(), s.end()) 可能没有意义。您可以进行后处理来解决这个问题：

s = std::string(s.begin(), std::find(s.begin(), s.end(), '\0'));

一个更复杂的版本，将每个字符串单独复制到 char[] 中：

typedef std::unique_ptr<char[]> pointer;
std::vector<pointer> args;
std::transform(strings.begin(), strings.end()
               , std::back_inserter(args)
               , [](std::string const& s) -> pointer
{
    pointer p(new char[s.size()]);
    std::copy(s.begin(), s.end(), &p[0]);
    return p;
});

std::for_each(args.begin(), args.end(), [nterms](pointer& p)
{ ModelInitialize(p.get(), nterms); });

Answer 5

const char* 也与 char* 相同，只是 const_ness 不同，您的接口方法既接受 const 字符串，也接受非 const 字符串。

c_str() 不是返回 const char 吗？如果我只是
需要一个字符*？

是的，它返回一个 const 字符串，不，应该没有问题

const char*a="something";
////whatever it is here
const char* retfunc(const char*a)
{
   char*temp=a;
   //process then return temp
}

返回本地对象不被很多人接受，这个小例子是按原样提供的。

Answer 6

向量的元素连续存储，所以最好、最简单的方法是：

std::vector<char> v;
char* c = &v[0];