c++ - std::vector <std::string> 到 char* 数组

我有一个std::vector<std::string>,我需要使用C的参数来读取char* foo ,作为C++的新手,我尝试在向量的每个元素上执行这个转换并生成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,delete从vs中删除,vc (i)仍然有效!

但是,如果你不希望这种灵活性,那么你可以使用这个convert函数:


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

你必须把std::vector<char*>改成std::vector<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());

这应该可以工作:


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());
}

如果你的C函数修改了这个数组,你可能需要获取这些数据结构。


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

const char*也是char*相同,只是const_ness,不同界面方法接受const和非const字符串。

不c_str( ) 返回一个const char? 那也是个问题如果仅需一个char*?

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

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

返回本地对象不被很多人接受和这个小示例中提供了一个名为as 。

一个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); }


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); });

向量的元素是连续存储,所以最好的方法是:


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

...