Qt Qstring <not accessible> and SIGSEGV segmantation fault - c++

Question

I'm seeing a strange segmentation fault when accessing a QString type struct member from GET_STATION_MODEL_PARAMS_t. The execution is stopped at **:
code:
#include <QDebug>
#include "hradcontroller.h"
#include "hradAPI.h"
#define TAG "HRAD_CONTROLLER:\0"
#define HRAD_API_VERSION "2"
#define MANUFACTURER_KEY "abcde12345"
typedef struct registerDeviceParams{
QString brand;
QString device;
QString manufacturer;
QString model;
QString serial;
QString ibd;
QString ibkey;
QString version;
QString track;
registerDeviceCB_t cbFn;
}REGISTER_DEVICE_PARAMS_t;
typedef struct getStationModelParams{
int stationID;
QString ibd;
QString ibkey;
QString version;
QString track;
getStationModelCB_t cbFn;
GET_STATION_MODEL_RESPONSE_t* resp;
}GET_STATION_MODEL_PARAMS_t;
HRAD *hbr = new HRAD();
void registerDevice(){
REGISTER_DEVICE_PARAMS_t params;
params.brand = "brand";
params.device = "TI-J6";
params.manufacturer = "manuf";
params.model = "EVK";
params.ibkey = MANUFACTURER_KEY;
params.serial = "abcde12345";
params.version = HRAD_API_VERSION;
params.track = "true";
params.cbFn = deviceRegisteredCB;
hbr->registerDevice(&params);
}
void getStationModel(int id){
GET_STATION_MODEL_PARAMS_t params;
params.stationID = id;
params.ibd = hbr->getId();
params.ibkey = "abdef";
params.version = "2";
** params.track = "false"; //SIGSEGV segmantation fault here
params.cbFn = stationModelAvailableCB;
params.resp = &g_StationModel;
}
void deviceRegisteredCB(QString ibd){
qDebug() << TAG << "Device Registered: ibd = " << ibd;
getStationModel(currentPublicStationID);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
/* Register ourselves to HRAD Server */
registerDevice();
}
Values just before the seg. fault:
If you notice "track" is "not accessible" while debugging and this causes crash.
I modified GET_STATION_MODEL_PARAMS_t like this:
typedef struct getStationModelParams{
int stationID;
QString foo; //dummy variable.
QString ibd;
QString ibkey;
QString version; //seg. fault here now
QString track;
getStationModelCB_t cbFn;
GET_STATION_MODEL_RESPONSE_t* resp;
}GET_STATION_MODEL_PARAMS_t;
And values became like this:
Now "version" is also "not accessible".
Any idea why is this happening?
Thanks.
Update 1:
Tools:
Qt Creator 3.4.1 (ubuntu 14.04)
Qt 5.4.2 (GCC 4.6.1, 64 bit)

Answer 1

TL;DR: This is why you really need to post all the code needed to reproduce the crash.
Your code works - no crashes. Your question is thus answered, even if the answer is completely useless to you, and everyone else too. Don't ask questions that can only be answered in a way that can't help you.
The only thing that stands out in your code, besides it being a horrible C abomination with no place in modern C++, is that the HRAD instance is created before main starts executing. Depending on what HRAD's constructor is doing, this might be a bad thing.
But let's see if we can fix your code up some, to guide you to write safer code.
Old Code
First, let's start with your code verbatim, with some additions at the beginning and end to get it to compile and execute.
You should have provided all that in your question - with enough of "other stuff" to crash. The below, assuming that it crashed or otherwise reproduced your problem, would be considered an sscce and make your question valuable to the community.
#include <QString>
#include <QDebug>
typedef void (*registerDeviceCB_t)(QString);
typedef void (*getStationModelCB_t)();
typedef struct getStationModelResponse {} GET_STATION_MODEL_RESPONSE_t;
void deviceRegisteredCB(QString);
void stationModelAvailableCB() {}
typedef struct registerDeviceParams REGISTER_DEVICE_PARAMS_t;
struct HRAD {
void registerDevice(REGISTER_DEVICE_PARAMS_t*);
QString getId() { return QString(); }
};
GET_STATION_MODEL_RESPONSE_t g_StationModel;
int currentPublicStationID = 1;
void registerDevice();
void getStationModel(int);
int main()
{
registerDevice();
getStationModel(0);
return 0;
}
// Your code verbatim beyond this point
Your code, copy-pasted for reference (with apparently irrelevant MainWindow removed):
#define TAG "HRAD_CONTROLLER:\0"
#define HRAD_API_VERSION "2"
#define MANUFACTURER_KEY "abcde12345"
typedef struct registerDeviceParams{
QString brand;
QString device;
QString manufacturer;
QString model;
QString serial;
QString ibd;
QString ibkey;
QString version;
QString track;
registerDeviceCB_t cbFn;
}REGISTER_DEVICE_PARAMS_t;
typedef struct getStationModelParams{
int stationID;
QString ibd;
QString ibkey;
QString version;
QString track;
getStationModelCB_t cbFn;
GET_STATION_MODEL_RESPONSE_t* resp;
}GET_STATION_MODEL_PARAMS_t;
HRAD *hbr = new HRAD();
void registerDevice(){
REGISTER_DEVICE_PARAMS_t params;
params.brand = "brand";
params.device = "TI-J6";
params.manufacturer = "manuf";
params.model = "EVK";
params.ibkey = MANUFACTURER_KEY;
params.serial = "abcde12345";
params.version = HRAD_API_VERSION;
params.track = "true";
params.cbFn = deviceRegisteredCB;
hbr->registerDevice(&params);
}
void getStationModel(int id){
GET_STATION_MODEL_PARAMS_t params;
params.stationID = id;
params.ibd = hbr->getId();
params.ibkey = "abdef";
params.version = "2";
params.track = "false"; //SIGSEGV segmantation fault here
params.cbFn = stationModelAvailableCB;
params.resp = &g_StationModel;
}
void deviceRegisteredCB(QString ibd){
qDebug() << TAG << "Device Registered: ibd = " << ibd;
getStationModel(currentPublicStationID);
}
// End of verbatim code
And, finally, the implementation of registerDevice:
void HRAD::registerDevice(REGISTER_DEVICE_PARAMS_t* params) {
params->cbFn("some ibd");
}
These three pieces, when put into a main.cpp, will compile, run, and properly invoke the callback. To wit:
Starting bad-c-aargh-31542746...
HRAD_CONTROLLER: Device Registered: ibd = "some ibd"
bad-c-aargh-31542746 exited with code 0
Rework
It seems that you're using callbacks and passing values via pointers, as you would in C. We'll get rid of the C typedefs that are unnecessary in C++, and we will leverage C++11's features to make the callbacks much more usable.
As above, the code below is merely interspersed with the commentary. You could copy-paste it to a main.cpp, remove the commentary, compile it and run. It is complete.
First, let's include the functional header to bring in std::function, and we shall get rid of C-style macros:
#include <QString>
#include <QDebug>
#include <functional>
const QString TAG = QStringLiteral("HRAD_CONTROLLER:");
const QString HRAD_API_VERSION = QStringLiteral("2");
const QString MANUFACTURER_KEY = QStringLiteral("abcde12345");
Then we shall define the structures used to pass parameters to HRAD methods, and to obtain the responses from these methods:
struct RegisterDeviceParams {
QString brand;
QString device;
QString manufacturer;
QString model;
QString serial;
QString ibd;
QString ibkey;
QString version;
QString track;
};
struct GetStationModelParams {
int stationID;
QString ibd;
QString ibkey;
QString version;
QString track;
};
struct GetStationModelReponse {};
We can then implement a skeleton HRAD class. The parameters are passed as const references. The optional callbacks can be compatible lambdas, functor instances, function pointers, etc. The provision of default-constructed values makes them optional. You can leave them out from a call, the compiler will use the defaults instead. The currentPublicStationID, presumably a global variable, belongs in HRAD, too.
class HRAD {
public:
void registerDevice(const RegisterDeviceParams &,
const std::function<void(const QString & ibd)> & cb
= std::function<void(const QString&)>()) {
cb("some ibd");
}
void getStationModel(const GetStationModelParams &,
const std::function<void(const GetStationModelReponse &)> & cb
= std::function<void(const GetStationModelReponse&)>()) {
GetStationModelReponse response;
cb(response);
}
QString getId() { return "some id"; }
int currentPublicStationID;
HRAD() : currentPublicStationID(1) {}
};
The global instance of HRAD is defined using the Q_GLOBAL_STATIC macro. It will be instantiated, thread-safely, upon first use. It acts as a pointer - to get the global instance, you should use the -> operator.
Q_GLOBAL_STATIC(HRAD, hbr) // no semicolon needed
The getStationModel and registerDevice functions will use lambda syntax to instantiate the callbacks on the spot. Of course if the callbacks were more complex, you could put them in stand-alone functions or methods.
void getStationModel(int id){
GetStationModelParams params;
params.stationID = id;
params.ibd = hbr->getId();
params.ibkey = "abdef";
params.version = "2";
params.track = "false";
hbr->getStationModel(params, [](const GetStationModelReponse&){
qDebug() << "got station model";
});
}
void registerDevice(){
RegisterDeviceParams params;
params.brand = "brand";
params.device = "TI-J6";
params.manufacturer = "manuf";
params.model = "EVK";
params.ibkey = MANUFACTURER_KEY;
params.serial = "abcde12345";
params.version = HRAD_API_VERSION;
params.track = "true";
hbr->registerDevice(params, [](const QString & ibd){
qDebug() << TAG << "Device Registered: ibd = " << ibd;
getStationModel(hbr->currentPublicStationID);
});
}
Finally, we call registerDevice from main:
int main()
{
registerDevice();
return 0;
}
This code works, and produces the following output:
Starting bad-c-aargh-31542746...
"HRAD_CONTROLLER:" Device Registered: ibd = "some ibd"
got station model
bad-c-aargh-31542746 exited with code 0
Note the absence of any manual memory management. Raw pointers aren't used either - neither as parameters, nor as members.