声明稍后初始化的结构成员（C++）

Question

I need to have a variable that is declared in a struct to be initialised with a value later. It's basically because its initialisation depends on another member of the structure, which only has a value after some functions have been done.

This sounds a bit weird, so I'll show my code:

struct frame
{
    Mat thresholded;
    vector<vector<Point> > contrs;
    vector<Moments> momts;
};

frame obj_detect(frame img)
{
    // Get contours from image
    findContours(img.thresholded, img.contrs, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
    // Initialise moments vector big enough for all contours' moments
    img.moments(img.contrs.size());
    ...
    return img;
}

int main()
{
     frame frame1;
     frame1 = obj_detect(frame1);
     ...
}

Currently this code throws this error: error: no match for call to '(std::vector<cv::Moments>) (std::vector<std::vector<cv::Point_<int> > >::size_type)'

How should I initialise the moments vector array so that it has enough space for all the contours?

Answer 1

There's nothing wrong or weird about what you're trying to do. This is an example of an initializer function (or what would be called a constructor for a class).

What isn't entirely clear is whether struct1 is meant to be the struct you are initializing or if it is an input that you are using to return a new struct (since your function does define its return type as my_struct as well). In either case, it is generally recommended to pass your structs by reference rather than by value or as return values.

You could try something like this:

void my_function(const my_struct& input_struct, my_struct& output_struct)
{
  ...
  output_struct.size = ...;
  output_struct.my_array = new char[output_struct.size];
  ...
}

Of course, if you really are using C++, you should question why you are using a struct to represent what seems to be a string?

Once you've allocated memory this way, it is important that you free the memory as well in order to avoid memory leaks. A single object can be deallocated using delete , but an array should be deallocated using delete [] , for example:

delete [] some_struct.my_array;

Additionally, it is considered good practice to set pointers to null after deallocating them to avoid referencing stale memory segments. This can be done like this:

some_struct.my_array = nullptr;

Finally, this all gets a bit tedious to manage, particularly if the lifetime and ownership of the object is more complex. To deal with this, the standard library has unique_ptr and shared_ptr objects that will automatically deallocate an object when it is no longer being used.

I don't think it makes sense to go into detail about the differences and uses of each since there are innumerable resources here and elsewhere on the topic.

Answer 2

You have to use malloc()

char* struct1.my_array = new char[struct1.size];

Edited: Actually you can use malloc or new. In this case - doesn't matter. If you prefer malloc you have to free memory with free(), otherwise you have to use new/delete. Usually new/delete is good to be used while creating objects, when you are dealing with structs and primitive type stick to malloc.

New/Delete operator are usually invokes constructors/destructors and they are a little bit slower than malloc/free. So why you have to pay (even a little) performance cost for nothing?

Answer 3

Seems to me this is very simple question

    my_struct my_function(my_struct struct1)
    {
        ...
        struct1.my_array = malloc(struct1.size); // Initialise the array
        ...
    }