std::vector<std::string> in char*-Array

Ich habe einen std::vector<std::string> die ich für eine C verwenden muss Argument der Funktion, das char* foo lautet . Ich habe gesehen, wie man einen std::string umwandelt bis char* . Als Neuling bei C++ , versuche ich herauszufinden, wie diese Konvertierung für jedes Element des Vektors durchgeführt und der char* erzeugt wird Array.

Ich habe mehrere eng verwandte SO-Fragen gesehen, aber die meisten scheinen Möglichkeiten zu veranschaulichen, in die andere Richtung zu gehen und std::vector<std::string> zu erstellen .

Antworten:

Sie können std::transform verwenden als:

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

Dazu müssen Sie convert() implementieren als:

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

Testcode:

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

Ausgabe:

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

Online-Demo:http://ideone.com/U6QZ5

Sie können &vc[0] verwenden wo immer Sie char** brauchen .

Beachten Sie, dass wir new verwenden Speicher für jeden std::string zuzuweisen (unter convert Funktion), müssen wir am Ende den Speicher freigeben. Dadurch können Sie den Vektor vs flexibel ändern; Sie können push_back weitere Zeichenfolgen hinzufügen, löschen Sie die vorhandene aus vs , und vc (also vector<char*> weiterhin gültig!

Wenn Sie diese Flexibilität jedoch nicht möchten, können Sie diesen convert verwenden Funktion:

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

Und Sie müssen std::vector<char*> ändern bis std::vector<const char*> .

Jetzt nach der Transformation, wenn Sie vs ändern durch Einfügen neuer Zeichenfolgen oder durch Löschen der alten daraus, dann alle char* in vc könnte ungültig werden. Das ist ein wichtiger Punkt. Ein weiterer wichtiger Punkt ist, dass Sie delete vc[i] nicht verwenden müssen in Ihrem Code nicht mehr.

Einige Code-Antworten

std::transform(vs.begin(), vs.end(), std::back_inserter(vc), 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*>

const char *convert(const std::string &
s) {    return s.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());
} 

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

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

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*a="something";
////whatever it is here const char* retfunc(const char*a) {    char*temp=a;
   //process then return temp } 

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