std：：vector<std：：string> to char* 数组

您可以使用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<char*>将仍然有效!

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

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

你必须把std::vector<char*>改成std::vector<const char*>。

现在在转换之后，如果您通过插入新字符串或删除其中的旧字符串来更改vs，那么vc中的所有char*可能都无效。这是很重要的一点。另一个要点是，您不再需要在代码中使用delete vc[i]。

你能做的最好的是分配一个const char*的std::vector与你的向量相同的大小。然后，遍历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::strings中获取const char* s和调用c函数之间调整字符串的原始向量的大小。

应该可以:

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函数不修改字符串，则可能没有必要复制字符串。如果你能详细说明你的界面是什么样子的，我相信我们可以为你提供更好的帮助。

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(), ''));

一个更复杂的版本，将每个字符串分别复制到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); });

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
}

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

vector的元素是连续存储的，所以最好且最简单的方法是:

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