Accessing properties of pointer to struct changing values - c++11

Question

I think that I am missing something fundamental with regards to pointers. I have the following code:
alicat_data *data = (alicat_data*)ent.second->get_data();
if(ent.first == "AlicatA"){
ui->ac0_P->setValue(data->pressure);
ui->ac0_T->setValue(data->temperature);
ui->ac0_Q->setValue(data->flow_rate);
ui->ac0_Q0->setValue(data->mass_flow_rate);
ui->ac0_Qsp->setValue(data->setpoint);
}
which references a struct that is defined as follows:
struct alicat_data : Data {
float pressure; /** Pressure in mb */
float temperature; /** Temperature in degC */
float flow_rate; /** Volumetric low rate; units are defined by the model */
float mass_flow_rate; /** Mass flow rate; units are defined by the model */
float setpoint; /** Device setpoint (if it is a controller); units are defined by the model */
gas gas_; /** Enum as defined above representing the gas */
alicat_data(float p = 0, float T = 0, float Q = 0,
float Q0 = 0, float sp = 0, gas g = Air):pressure(p),
temperature(T), flow_rate(Q), mass_flow_rate(Q0),
setpoint(sp), gas_(g){
setTime();
}
virtual std::string serialize2ascii(){return std::to_string(pressure)
+ "\t" + std::to_string(temperature)
+ "\t" + std::to_string(flow_rate) + "\t" + std::to_string(mass_flow_rate)
+ "\t" + std::to_string(setpoint);}
};
When the topmost code is executed, the first reference, data->pressure returns correctly then it looks like everything at that address becomes garbage and data returned subsequent to this first reference (i.e. data->temperature, etc) is not correct.
I can fix this by doing the following
alicat_data data_ = *data;
but would prefer not to do this. What am I doing wrong that is creating the issue that I am seeing?

Answer 1

With get_data() you are getting pointer to block of memory of alicat_data and it is stored into the varable alicat_data *data, that is a pointer.
With alicat_data data_ = *data; you are getting the block of memory of the instance, so you can access its methods and properties with a dot '.'.
You can remove the variable alicat_data data_ = *data; and use the variable alicat_data *data as follow:
for (auto const &ent : alicat_map){
alicat_data *data = (alicat_data*)ent.second->get_data();
if(ent.first == "AlicatA"){
ui->ac0_P->setValue(data->pressure);
ui->ac0_T->setValue(data->temperature);
ui->ac0_Q->setValue(data->flow_rate);
ui->ac0_Q0->setValue(data->mass_flow_rate);
ui->ac0_Qsp->setValue(data->setpoint);
}
}
Update: Check this link to review the theory of pointers http://www.cplusplus.com/doc/tutorial/pointers/
Also I made a program with some of you to show you the tow ways, your and mine:
#include <iostream>
#include <map>
using namespace std;
struct alicat_data {
float pressure; /** Pressure in mb */
float temperature; /** Temperature in degC */
float flow_rate; /** Volumetric low rate; units are defined by the model */
float mass_flow_rate; /** Mass flow rate; units are defined by the model */
float setpoint; /** Device setpoint (if it is a controller); units are defined by the model */
alicat_data(float p = 0, float T = 0, float Q = 0,
float Q0 = 0, float sp = 0) {
pressure = p;
temperature = T;
flow_rate = Q;
mass_flow_rate = Q0;
setpoint = sp;
}
virtual std::string serialize2ascii() {
return "dummy";
}
};
int main()
{
map<string, alicat_data *> alicat_map;
map<string, alicat_data *>::iterator entM;
alicat_map["AlicatA"] = new alicat_data(1.1,2.2,3.3,4.4,5.5);
alicat_map["AlicatB"] = new alicat_data(12.1, 23.2, 34.3, 45.4, 56.5);
//Your Way
for (auto const &ent : alicat_map) {
alicat_data *data = (alicat_data*)ent.second; //Get the alicat_data* (pointer) element
if (ent.first == "AlicatA") {
alicat_data data_ = *data;
float pressure = data_.pressure;
float temp = data_.temperature;
float rate = data_.flow_rate;
float mflowrate = data_.mass_flow_rate;
float setpoint = data_.setpoint;
}
}
//My Way
for (entM = alicat_map.begin(); entM != alicat_map.end(); entM++)
{
alicat_data *data = entM->second; //Get the alicat_data* (pointer) element
if (entM->first == "AlicatA") {
float pressure = data->pressure;
float temp = data->temperature;
float rate = data->flow_rate;
float mflowrate = data->mass_flow_rate;
float setpoint = data->setpoint;
}
}
return 0;
}
Upgrade of Apirl 13:
I was checking the code of your classe alicat and i found it:
Data *alicat::get_data(){
alicat_data* ac_data = new alicat_data(0, 0, 0, 0, 0, Air);
alicat_data addr_data = parse_data(port->async_rw(string(1, address)));
ac_data = &addr_data;
return (Data*) ac_data;
}
I notice that you are returning a address of a local variable, ac_data = &addr_data;, that will be deleted after the method Data *alicat::get_data() is finished. That is the reason that you have a mess with data that you getting after invoke getData.
To fix it you must avoid return local variables because they are destroyed after onece the program get out of the context. Return an instance that is previously reserved with the operator new. At the moment that the object is destroyed you have the symptoms that you describe.
I notice that you have the same problem in the method alicat_data alicat::parse_data(const std::string &msg).
UPDATE: Considere this:
I'm not sure why did you get that behaivor, but i know that the local variable ac_data is delete after the context of getData is over but the memory that you allocate intoparse_data is still there, when you are returning the address of that local variable, return (Data*) ac_data; its memory released (a block of memor that is allocated into the stack and not into the heap) and it could be the reason that you are see garbage but when you use alicat_data data_ = *data; you are rescue the memory Block allocated into parse_data... How!? That si a good question and it coul be depend of compilar but the way you can prove it is debugging and be careful of each memory address that you are getting in:
The addres of memory that is allocated into parse_data
The address
of pointer that is returned to getData from parse_data`.
The
address of memory that is set to local variable alicat_data
addr_data into getData. The address of pointer of the local
variable alicat_data addr_data that is returned from getData.
Once you leave getData, compare the addres of the pointer
alicat_data *data vs the address of pointer that you got in
parse_data and compare the address.