std::Vektor zum char*-Array

Question 1

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

Ich habe mehrere eng verwandte SO-Fragen gesehen, aber die meisten scheinen Wege zu veranschaulichen, wie man in die andere Richtung gehen und etwas erschaffen kann std::vector<std::string>.

Question 2

Sie können verwenden std::transform wie:

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

Was Sie implementieren müssen convert() wie:

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 verwenden &vc[0] wo immer Sie brauchen char**.

Beachten Sie, dass da wir verwenden new Speicher für jeden zuzuweisen std::string (in convert Funktion), müssen wir am Ende den Speicher freigeben. Dies gibt Ihnen die Flexibilität, den Vektor zu ändern vs; du kannst push_back Wenn Sie weitere Zeichenfolgen hinzufügen möchten, löschen Sie die vorhandene aus vsund vc (dh vector<char*> bleibt gültig!

Aber wenn Sie diese Flexibilität nicht wollen, dann können Sie diese nutzen convert Funktion:

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

Und du musst dich ändern std::vector<char*> zu std::vector<const char*>.

Jetzt nach der Transformation, wenn Sie sich ändern vs 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 es nicht verwenden müssen delete vc[i] in Ihrem Code mehr.

Question 3

Das Beste, was Sie tun können, ist ein zuzuweisen std::vector von const char* die gleiche Größe wie Ihr Vektor. Gehen Sie dann durch jedes Element des Vektors und rufen Sie c_str() um das String-Array zu erhalten und das entsprechende Element des Arrays zu speichern. Dann können Sie den Zeiger auf das erste Element dieses Vektors an die betreffende Funktion übergeben.

Der Code würde so aussehen:

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

Beachten Sie, dass Sie kann nicht Ermöglichen Sie es, dass der ursprüngliche Vektor der Zeichenfolgen zwischen dem Abrufen der Größe geändert wird const char*s aus der std::stringsund die Zeit, zu der Sie die C-Funktion aufrufen.

Question 4

Das sollte funktionieren:

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

BEARBEITEN:

So würden Sie diese Datenstrukturen freigeben, vorausgesetzt, vec hat immer noch die richtige Anzahl von Elementen. Wenn Ihre C-Funktion dieses Array irgendwie ändert, müssen Sie die Größe möglicherweise auf andere Weise ermitteln.

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

Nochmals BEARBEITEN:

Es ist möglicherweise nicht erforderlich, die Zeichenfolgen zu kopieren, wenn Ihre C-Funktion die Zeichenfolgen nicht ändert. Wenn Sie erläutern können, wie Ihre Benutzeroberfläche aussieht, können wir Ihnen sicher besser helfen.

Question 5

Eine C++0x-Lösung, bei der Elemente von std::string werden garantiert zusammenhängend gespeichert:

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

Wenn die Funktion null ihr Argument beendet, dann nach dem Aufruf (s.begin(), s.end()) vielleicht nicht aussagekräftig. Sie können dies nachbearbeiten, um das zu beheben:

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

Eine aufwändigere Version, die jede Zeichenfolge separat in a kopiert 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); });

Question 6

const char* ist auch dasselbe wie char*, nur unterschiedlich in der const_ness, Ihre Schnittstellenmethode akzeptiert sowohl konstante als auch nicht konstante Zeichenfolgen.

Gibt c_str() kein const char zurück? Wird das ein Problem sein, wenn ich nur ein Zeichen* brauche?

Ja, es gibt eine konstante Zeichenfolge zurück und nein, es sollte kein Problem geben

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

Die Rückgabe eines lokalen Objekts wird von vielen Leuten nicht akzeptiert, und dieses kleine Beispiel wird so wie es ist bereitgestellt.

Question 7

Die Elemente eines Vektors sind zusammenhängend gespeichertalso ist der beste und einfachste Weg:

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