Initializing a Struct's variable const char* const* with C++

The structure being used effectively uses a C-style approach to defining a variable sized array of pointers to char (with const sprinkled over it). You’ll need storage for both the array of char const* as well as the entities pointed to. Here is how you could build it from a std::vector<std::string>:

std::vector<std::string> strings = somehow_compute_the_strings();
std::vector<char const*> array;
for (std::string const& s: strings) {
    array.push_back(s.c_str());
}

Answer answer = { array.data(), array.size() };

Of course, you can’t return answer without the pointer inside pointing to stale data: you’d need to keep the two std::vectors alive. Potentially these two objects could be made members of an object the function is called on. To actually return an object of type Answer without a place to hold on to the std::vectors you could allocate the relevant entities and accept that the result will yield a memory leak unless the caller can clean the result up.

You can't just cast stuff. struct Answer is expecting a char**, so you are going to have to build it and keep it valid as long as the struct Answer is in use. At least they were kind enough to let us know they don't intend to modify it or mess with cleaning up the memory, since it takes "const char * const *".

#include <iostream>
#include <vector>
#include <string>
#include <assert.h>

typedef std::vector<std::string> VectorOfStrings_type;

struct Answer
{
    const char* const* lastNames;
    unsigned numberOfPeople;
};

class AnswerWrapper
{
private:
    // construct and maintain memory so the pointers in the Answer struct will be valid
    char ** lastNames;
    unsigned int numberOfPeople;

public:
    AnswerWrapper(const VectorOfStrings_type &input){
        numberOfPeople = input.size();

        // create the array of pointers
        lastNames = static_cast<char**>(
            malloc(numberOfPeople * sizeof(char*)) 
        );

        // create each string
        for (unsigned int i = 0; i < numberOfPeople; ++i){
            const std::string &name = input[i];

            // allocate space
            lastNames[i] = static_cast<char*>(
                malloc(name.size() + 1)
            );

            // copy string
            strncpy(lastNames[i], name.data(), name.size());

            // add null terminator
            lastNames[i][name.size()] = '\0';
        }
    }

    operator Answer (){
        return Answer{ lastNames, numberOfPeople };
    }

    ~AnswerWrapper(){
        // critcally important, left as an exercise
        assert(0);
    }
};

void SomeFunctionWhichUsesAnswer(Answer a){
    // presumably you have some legacy C code here
    // but here's a quick and easy demo
    for (unsigned int i = 0; i < a.numberOfPeople; ++i)
        std::cout << a.lastNames[i] << std::endl;
}

int main() {
    // Here is your vector of strings
    VectorOfStrings_type myData { "custom formatted data goes here", "and more here", "and again" };

    // You must construct a buffer for the "Answer" type, which must remain in scope
    AnswerWrapper temp{ myData };

    // AnswerWrapper is currently in scope, so inside this function, the pointers will be valid
    SomeFunctionWhichUsesAnswer(temp);
}

Also, I noticed that the strings in Answer are not referred to as null terminated. That is a separate issue you can take care of.