C++ can not store pointer in structure

Question

First off, I'm new to c++. If there's a better way to do this then a structure, please mention it.

So what I'm trying to do is create a structure to store pointers to some custom objects. The reason for this is instead of having to pass many pointers of parameters, I can declare this structure and pass the structure to the function that needs this group of objects.

The reason for all the objects is I am doing repative interactions with web services. I have made a class to simplify the interactions with the web services and do not wish to destroy and recreate them every time I need them.

Note: This is being done in Qt 5

This is in the header:

struct MyStruct
{
    MyClass* Class1;
    MyClass* Class2;
    MyClass* Class3;
    MyClass* Class4;
};

Now this is a snip of how I'm trying to fill in the structure:

//Stucture of commonly used objects, for all to access
MyStruct* theStruct;

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    //Build object
    MyClass* firstClass = new MyClass(/*params for object*/);
    theStruct->Class1 = firstClass;

    ui->setupUi(this);
    connect(firstclass, SIGNAL(dataReady()),this,SLOT(updateWebStats(MyStruct)));
}

And now the error I am getting:

App output:

Starting MyExe.exe Error - RtlWerpReportException failed with status code :-1073741823. Will try to

launch the process directly:

The program has unexpectedly finished. MyExe.exe crashed

When I debug I get a popup

The inferior stopped because it received a signal from the Operating System.

Signal name : SIGSEGV
Signal meaning : Segmentation fault

At this time the debugger is at this line, in the mainwindow constructor:

theStruct->Class1 = firstClass;

Answer 1

You are trying to access an unassigned pointer which results in a segmentation fault.

Try initialize it:

MyStruct* theStruct = new MyStruct();

Answer 2

I don't agree with the idea of using globals to make life easier. Are global variables bad?

But here is your error.

theStruct, must also be initialized.

If it is a static member, you should set it to zero.

And it is good practice to set the pointers for your classes to zero, too.

struct theStruct
{
    // default constructor
    theStruct() : Class1(0), Class2(0), Class3(0), Class4(0) {}
    MyClass* Class1;
    MyClass* Class2;
    MyClass* Class3;
    MyClass* Class4;
};

Then at time of access, you should check to make sure it is initialized with:

if(theStruct && theStruct->Class1)
    theStruct->Class1->foo();

The ordering of the above if statement does the following: if theStruct is not zero aka, has had new called and is a valid pointer, and if Class1 in theStruct is not zero (also has had new called on it), then use it because it is safe and available.

Hope that helps.

Answer 3

There appears to be no reason to use a pointer to MyStruct in your example. You should not be using one unless you have some compelling reason to do so, which does not appear to be the case. If you don't use a pointer, you don't need to initialize it in your code with new. It is automatically intialized at compile time, by way of your declaration and definition.

MyStruct theStruct;

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    //Build object
    MyClass* firstClass = new MyClass(/*params for object*/);
    theStruct.Class1 = firstClass;

    ui->setupUi(this);
    connect(firstclass, SIGNAL(dataReady()),this,SLOT(updateWebStats(&MyStruct)));
}

See Resource Acquisition Is Initialization for starters. Far too many programmers automatically use pointers in C++ when they are not necesssary at all. Only use pointers when you absolutely need them, and in C++11 use std::shared_ptr and std::unique_ptr whenever possible.

Do not confuse C++ with languages like Java, Delphi, or C#, which require you to allocate classes on the free store and access them only with references/pointers. In C++ you can and should declare stack based variables for class and struct objects.

If there's a better way to do this then a structure, please mention it.

std::vector<MyClass*> might be preferable. See: std::vector:

std::vector is a sequence container that encapsulates dynamic size arrays.

The elements are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets on regular pointers to elements. This means that a pointer to an element of a vector may be passed to any function that expects a pointer to an element of an array....