C++ Object value suddenly becomes NULL with no related prior instruction - c++

Question

NOTE: Reopened question with more details.
So here we have some code
someCode.cpp
(...)
MyStruct sct = performRequest(.... .... ....); //Line 1
std::cout << "Line 2";
std::cout << "Line 3";
(...)
someCode.hpp (for struct MyStruct)
(...)
struct MyStruct {
char** memory;
int* response_code;
};
(...)
performRequest() function
static size_t
WriteMemoryCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
size_t realsize = size * nmemb;
struct MemoryStruct* mem = (struct MemoryStruct*)userp;
char* ptr = (char*) realloc(mem->memory, mem->size + realsize + 1);
if (ptr == NULL) {
/* out of memory! */
printf("not enough memory (realloc returned NULL)\n");
return 0;
}
mem->memory = ptr;
memcpy(&(mem->memory[mem->size]), contents, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
return realsize;
}
MyStruct performRequest(std::string requestType, std::string URL, std::string requestParameters, struct curl_slist* headersList, std::string requestFields) {
CURL* curl_handle = curl_easy_init();
CURLcode curl_code;
struct MemoryStruct chunk;
chunk.memory = (char*) malloc(1); /* will be grown as needed by the realloc above */
chunk.size = 0; /* no data at this point */
curl_easy_setopt(curl_handle, CURLOPT_BUFFERSIZE, 102400L);
curl_easy_setopt(curl_handle, CURLOPT_URL, (URL + requestParameters).c_str());
curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, true);
curl_easy_setopt(curl_handle, CURLOPT_HEADER, false);
if (!requestFields.empty()) {
curl_easy_setopt(curl_handle, CURLOPT_POSTFIELDS, requestFields.c_str());
}
if (headersList != NULL) {
curl_easy_setopt(curl_handle, CURLOPT_HTTPHEADER, headersList);
}
curl_easy_setopt(curl_handle, CURLOPT_MAXREDIRS, 50L);
curl_easy_setopt(curl_handle, CURLOPT_CUSTOMREQUEST, requestType.c_str());
curl_easy_setopt(curl_handle, CURLOPT_VERBOSE, false);
curl_easy_setopt(curl_handle, CURLOPT_TCP_KEEPALIVE, true);
/* send all data to this function, we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void*)& chunk);
curl_code = curl_easy_perform(curl_handle);
/* check for errors */
if (curl_code != CURLE_OK) {
fprintf(stderr, "curl_easy_perform() failed: %s\n",
curl_easy_strerror(curl_code));
}
int response_code;
curl_easy_getinfo(curl_handle, CURLINFO_RESPONSE_CODE, &response_code);
/* cleanup curl stuff */
curl_easy_cleanup(curl_handle);
MyStruct res;
res.memory = &chunk.memory;
res.response_code = &response_code;
return res;
}
If we debug someCode.cpp and add two breakpoints in lines 2 and 3...
(...)
MyStruct sct = performRequest(···,···,···); //Line 1
[BREAKPOINT (1) HERE] std::cout << "Line 2";
[BREAKPOINT (2) HERE] std::cout << "Line 3";
(...)
...see the following images about the resulting values by the debugger, for the struct sct.
(which corresponds to Breakpoint 1) :)
(which corresponds to Breakpoint 2) :(
As you can see, the values in sct change to NULL without prior instruction. I don't know why this happens, although I suspect it might be something pointer-related...
So to deal with the object lifetime (sct), I changed performRequest() to this:
RequestResponse* performRequest(···) {
(···)
return new RequestResponse(&chunk.memory,&response_code);
}
but still I have the same problem.
Hope you have any idea and thanks!

Answer 1

Your issue is right here:
MyStruct res;
res.memory = &chunk.memory;
res.response_code = &response_code;
return res;
You're supplying res with the address of two local variables. So the second that function ends and you return the struct with those pointers, they're both invalid. Thus leading to this undefined behavior.
You could allocate new pointers on the heap there and seed them with the values of chunk.memory and response_code. Since they're on the heap, they'll persist until you free the memory, so that'd work.
However, I'd strongly suggest moving to a std::vector<std::string> instead of your char** and move to a raw int instead of int* if possible so you don't even need to worry about UB like this.