Question

I am having trouble understanding how the C++ std::vector container would get freed in the following scenario

void DoSomething()
{
   cv::Point ** curves;
   int * curve_sizes;
   num_curves = m_curves.size(); //member variable holdings curves
   curves = new cv::Point*[num_curves];
   curve_size = new int[num_curves];

   std::vector<cv::Point> cur_points;
   for(int i = 0; i < num_curves; ++i)
   {
     cur_points = CreatePolyPoints(m_curves[i]);
     curves[i] = &cur_points[0];
     curve_sizes = cur_points.size();
   }

   cv::fillPoly(m_roi, curves, curve_sizes, num_curves, ... );

   //Clear the dynamic data
   // Do i do aything here?   
   delete [] curves;
   delete [] curve_sizes;
}

std::vector<cv::Point> CreatePolyPoints(Curve curve)
{
   std::vector<cv::Point> points;

   //Do work here here
   while(something)
   {
     cv::Point cur_point;
     points.push_back(cur_point);
   }

   return points;
}

Thanks in advance. If anyone is interested in my goal: Generate an ROI given polygons defined by “n” curves.

Answer 1

It is not dynamically allocated so it will be destroyed as soon as it goes out of scope. In your case, your variable will go out of scope after the DoSomething() function exits. Your local variable cur_points gets the return value of CreatePolyPoints() assigned to it within your loop. When this happens, the old contents of cur_points will no longer exist – you do not need to worry about this, as the instances of Curve objects within that vector will get destroyed each time the vector gets reassigned. Similarly when cur_points goes out of scope.

EDIT: You do seem to have a problem here

std::vector<cv::Point> cur_points;
for(int i = 0; i < num_curves; ++i)
{
   cur_points = CreatePolyPoints(m_curves[i]);
   curves[i] = &cur_points[0];    // <-- problem
   curve_sizes = cur_points.size();
}

You assign the address of the vector element 0 to your ith element of curves at each iteration – The problem here is that that will be the address of an object that no longer exists. This is because the contents of the vector will no longer exist once cur_points gets reassigned next time in the loop iteration, therefore the pointers you are storing do not point to valid objects – they point to objects that have been destroyed already. When your loop finished, the vector will contain the contents returned in the last call to CreatePolyPoints. If you want to make sure that all the cv::Point objects still exist at the point you call cv::fillPoly you should consider passing the vector by reference to the CreatePolyPoints() function rather than return a new vector by value each time. This will ensure that ALL items you add via CreatePolyPoints will still exist once your loop finishes