konvertieren Sie vector<string> in char** C++

Ich habe eine vector<std::string> variable. Ich übergeben zu müssen, es auf eine Methode, die akzeptiert char**als input-parameter.

wie dies zu tun ? Wenn möglich und ich übergeben zu müssen, einen beschreibbaren.

Update 1:
Ein Werkzeug für die Erstellung einer service-Methode, gebe ich Parameter wie std::vector, aber es setzt automatisch die qualifier als &, was bedeutet, dass meine Methode definition die von dem tool generiert wird Aussehen wie:

std::string SvcImpl::myMethodname ( const std::string par1, const std::vector<     std::string >& par2, const std::vector< std::string >& par3 )
{

}

Diese Methode wird automatisch aufgerufen, mit den Werten in der patameter übergeben.
Jetzt von innen diese Methode werde ich rufen Sie eine Methode in einer dll in einen lib-Ordner, die wie folgt aussieht:

int method_to_be_called(char* par1, char ** par2, char ** par3, void* pRetValue);

für par1 --> ich bin vorbei (char*)par1.c_str()

Muss ich wissen, wie die übergabe von Variablen für par2 und par3 und für pRetValue.
Werte für par2 und par3 sind erhältlich in den vector, aber der Letzte parameter pRetValue ist ein output-parameter, das muss ich zurückgeben, da std::string.

sorry, wenn ich sehr verwirrend oder zu Fragen, ganz einfache Fragen.

dann wird Ihr Betrieb sollte auf *writable, vorausgesetzt, **beschreibbar ist, akzeptieren Sie Ihren char ** param.
Ich denke, Sie gehen zu müssen, um eine neue zu produzieren std::vector<char*> zum speichern der Adressen aller Ihrer string-Daten.
Was genau bedeutet dieser Methode übergeben Sie es zu tun?
Tun Sie wirklich brauchen, um zu kopieren Sie den Inhalt des strings in eine newed array, oder können Sie nur verwenden, einen Zeiger auf die zugrunde liegenden Daten direkt?
Die "zugrunde liegenden Daten" wäre ein array von string-Objekten, Sie können nicht einfach Durchlaufen, als wären Sie ein array von c-strings.

InformationsquelleAutor Mohamed Iqzas | 2014-09-25

  1. 23

    Ist es möglich, das problem zu lösen, ohne Sie zu kopieren alle std::strings solange die Funktion nicht ändern die übergebene char**. Anders kann ich mir keine alternative ein, sondern kopieren sich alles in ein neues char**` Struktur (siehe zweites Beispiel).

    void old_func(char** carray, size_t size)
{
    for(size_t i = 0; i < size; ++i)
        std::cout << carray[i] << '\n';
}

int main()
{
    std::vector<std::string> strings {"one", "two", "three"};
    std::vector<char*> cstrings;
    cstrings.reserve(strings.size());

    for(size_t i = 0; i < strings.size(); ++i)
        cstrings.push_back(const_cast<char*>(strings[i].c_str()));

    //Do not change any of the strings here as that will
    //invalidate the new data structure that relies on
    //the returned values from `c_str()`
    //
    //This is not an issue after C++11 as long as you don't
    //increase the length of a string (as that may cause reallocation)

    if(!cstrings.empty())
        old_func(&cstrings[0], cstrings.size());
}

    BEISPIEL 2: Wenn die Funktion ändern müssen, die übergebene Daten:

    void old_func(char** carray, size_t size)
{
    for(size_t i = 0; i < size; ++i)
        std::cout << carray[i] << '\n';
}

int main()
{
    {
        //pre C++11
        std::vector<std::string> strings {"one", "two", "three"};

        //guarantee contiguous, null terminated strings
        std::vector<std::vector<char>> vstrings;

        //pointers to rhose strings
        std::vector<char*> cstrings;

        vstrings.reserve(strings.size());
        cstrings.reserve(strings.size());

        for(size_t i = 0; i < strings.size(); ++i)
        {
            vstrings.emplace_back(strings[i].begin(), strings[i].end());
            vstrings.back().push_back('\0');
            cstrings.push_back(vstrings.back().data());
        }

        old_func(cstrings.data(), cstrings.size());
    }

    {
        //post C++11
        std::vector<std::string> strings {"one", "two", "three"};

        std::vector<char*> cstrings;   
        cstrings.reserve(strings.size());

        for(auto& s: strings)
            cstrings.push_back(&s[0]);

        old_func(cstrings.data(), cstrings.size());
    }
}

    HINWEIS: Überarbeitet, um einen besseren code.

    Gut, aber in der zweiten version würde ich benutzen Vektor oder zumindest einen unique_ptr zu halten, den Zeiger-array, und eine Art von scope_exit Anlage zu löschen, die der Zeiger innerhalb. Wenn einzelne string-Zuweisungen Versagen hier, alle bisherigen plus die Zeiger-array sind durchgesickert.
    in dem Kommentar von deinem code, du hast geschrieben, dass "dies ist nicht eine Frage nach C++11." kannst du bitte erklären, warum?
    Ich bearbeitete den Kommentar, wie es war nicht ganz korrekt. Aber bevor C++11 es gibt keine Garantie, dass die Zeiger zurückgegeben c_str() Punkte, um die Zeichenfolge tatsächlichen Daten (es kann eine temporäre Puffer). Nach C++11 es wird garantiert, um auf die strings die tatsächlichen Daten. Es ist nur ungültig, wenn Sie vergrößern die Länge des Strings.
    Ewig gesucht, für eine gute Antwort-das ist das, was ich brauchte, die sonst niemand erwähnt: der c_str () - Funktion! Danke!!!

    InformationsquelleAutor Galik

  2. 15

    Galik Antwort hat eine Reihe von Fragen der Sicherheit. Hier ist, wie ich es tun würde, in Modernem C++:

    #include <iostream>
#include <string>
#include <vector>

void old_func(char** carray, std::size_t size)
{
    for(std::size_t i(0); i < size; ++i)
        std::cout << carray[i] << '\n';
}

void other_old_func(const char** carray, std::size_t size)
{
    for(std::size_t i(0); i < size; ++i)
        std::cout << carray[i] << '\n';
}

int main()
{
    {
        std::cout << "modifiable version\n";
        std::vector<std::string> strings{"one", "two", "three"};
        std::vector<char*> cstrings{};

        for(auto& string : strings)
            cstrings.push_back(&string.front());

        old_func(cstrings.data(), cstrings.size());

        std::cout << "\n\n";
    }
    {
        std::cout << "non-modifiable version\n";
        std::vector<std::string> strings{"four", "five", "six"};
        std::vector<const char*> cstrings{};

        for(const auto& string : strings)
            cstrings.push_back(string.c_str());

        other_old_func(cstrings.data(), cstrings.size());
        std::cout << std::endl;
    }
}

    Keine unordentlichen memory management oder böse const_casts.

    Live auf Coliru.

    Ausgänge:

    modifiable version
one
two
three


non-modifiable version
four
five
six

    InformationsquelleAutor caps

Schreibe einen Kommentar