Char* data changes when accessed - c++

Question

I am working on a c++ application that has a function
//ControllerCore.cpp
Report ControllerCore::GetReport() {
unsigned char buf[256];
int res = 0;
while (res == 0) {
res = get_unsigned_char*(buf, sizeof(buf));
if (res < 0)
printf("Unable to read()\n");
#ifdef WIN32
Sleep(50);
#else
usleep(50 * 1000);
#endif
}
Report report = Report();
report.data = buf;
report.dataLength = res;
return report;
}
Report is defined as
//Report.h
struct Report
{
public:
unsigned char* data;
int dataLength;
};
When ContollerCore::GetReport() returns it assigns report.data to the pointer to an array of unsigned characters that I can work with fine. But when the caller tries to print report.data the values of the array change.
//Main.cpp
int RequestReport() {
Report report = core.GetReport();
for (int i = 0; i < report.dataLength; i++) {
std::cout << "0x" << std::hex << (int)report.data[i] << ", ";
}
std::cout << std::endl;
return 1;
}

Answer 1

You're returning a pointer to a local array. As soon as ControlerCore::GetReport returns, buf goes out of scope and is destroyed. Any attempt to access it after that leads to undefined behavior.
You need make Report actually hold the data directly. The easiest way would be to use a std::vector:
struct Report
{
std::vector<unsigned char> data;
// don't need dataLength anymore since std::vector knows its size
};
Report ControllerCore::GetReport() {
Report report;
report.data.resize(256);
int res = 0;
while (res == 0) {
res = get_data(report.data.data(), report.data.size());
}
report.data.resize(res);
return report;
}
Now that Report has only one member it probably isn't needed anymore, and you could just return std::vector<unsigned char> directly instead.
If you want to avoid the dynamic allocation used by std::vector, you could use std::array (or a raw array) instead:
struct Report
{
std::array<unsigned char, 256> data;
size_t dataLength; // back now, since the length of the data won't match the size of the contianer
};
Report ControllerCore::GetReport() {
Report report;
int res = 0;
while (res == 0) {
res = get_data(report.data.data(), report.data.size());
}
report.dataLength = res;
return report;
}
This avoids the dynamic allocation, but does incur an extra copy of the data since std::array can't be efficiently moved like std::vector can. That means that unless dynamic allocation is especially slow on your platform, the std::vector version is probably going to be faster.

Answer 2

You can try using report.data itself instead of buf.
Report ControllerCore::GetReport() {
Report report;
report.data=new char[256];
int res = 0;
while (res == 0) {
res = get_unsigned_char*(report.data, sizeof(char)*256);
if (res < 0)
printf("Unable to read()\n");
#ifdef WIN32
Sleep(50);
#else
usleep(50 * 1000);
#endif
}
report.dataLength = res;
return report;
}