How do I convert a vector<string> to a const char* const* in c++?

Question

I am trying to convert data into the right format for a specific unit test. The task is to mine a set of words, the unit tests will make sure the results are correct. I have no access to the unit tests, just the declaration which takes a const char* const* Result.

So I need to get my

std::vector<string> Words; 

to

const char* const* Result;

divided by a non-alpha char (for example space).

I am aware that this is a constant pointer to a constant character, so I am not sure what to do here since they both constant?

Any pointers (word pun not really intended) are appreciated!

Answer 1

Seems easy enough

#include <algorithm>
#include <functional>

// ...

std::vector<char const*> result_owner(Words.size());
std::transform(begin(Words), end(Words), begin(result_owner), 
               std::mem_fn(&std::string::c_str));

const char* const* Result = result_owner.data();

Just because Result must provide a const view of the buffer, doesn't mean the buffer has to really be const itself. So it's just another vector that we obtain by projecting Words on the std::string::c_str member.

After that Result can simply be another reference to result_owner.data(); .

This of course assumes that Result doesn't have to own the buffer it points at. Owning raw pointers are best avoided.

Answer 2

You cannot meaningfully convert one to the other. However, you can convert an array of std::string into an array of pointers to char, and a pointer to the first element of such array would be compatible with your desired result:

std::vector<const char*> Ptrs;
std::transform(
    std::cbegin(Words), std::cend(Words),
    std::back_inserter(Ptrs),
    [](auto& str)  { return str.c_str(); }
);
const char* const* Result = Ptrs.data();

Just remember that the strings themselves are still stored in the std::string objects and those pointers within the new vector are only valid as long as the strings in the original vector exist, aren't resized, and the original vector itself isn't resized.

And the pointer to first element of the new vector is only valid as long as that vector exists and isn't resized.

Answer 3

And the caveman way to do it :)

#include <iostream>
#include <vector>
#include <string>
#include <string.h>
using namespace std;

char **foo(const vector<string> &vec_of_strings)
{
    int num_strings = vec_of_strings.size();
    int max_str_len = 0;

    for (int i=0;i<num_strings;i++)
    {
        if (max_str_len < vec_of_strings[i].length()) {
            max_str_len = vec_of_strings[i].length();
        }
    }

    // for null termination ...
    max_str_len++;

    char **result = (char **) malloc(num_strings);

    for (int i=0;i<num_strings;i++)
    {
        result[i] = (char *) malloc(max_str_len);
        strcpy(result[i],vec_of_strings[i].c_str());
    }
    return result;
}

int main(int argc, char **argv)
{
    vector<string> vec_of_strings;

    vec_of_strings.push_back("Long");
    vec_of_strings.push_back("Livvvvvvvve");
    vec_of_strings.push_back("The");
    vec_of_strings.push_back("King");

    const char * const * Result = foo(vec_of_strings);

    for (int i=0;i<4;i++)
    {
        printf("%s\n",Result[i]);
    }
}