删除std::list导致访问冲突

Question

对于一个学校项目，我的团队正在使用OpenCV来捕获视频。从这些(自上而下)的图像中，提取对象的位置并将其转换为点列表。然后使用http://code.google.com/p/poly2tri/对这些点进行三角剖分(以克服可能存在的非凸对象的问题)。然后，使用三角化的地面窗格的坐标，我们使用freeglut在3D中绘制对象。(侧窗格和顶窗格是使用地面窗格坐标计算的)。我们遇到的问题是，当我们删除旧的点列表时，应用程序会随机崩溃。有时在1秒后，有时在30秒后，有时在几分钟后。我们得到的错误是“访问冲突写入位置0xCCCCCCCC”

我们的代码：

void WorldLayoutBuilder::update()
{
pointList.clear();

// Capture image
<code to capture image and get countours>

for(size_t i = 0; i < contours.size(); i++)
{
    if(contours[i].size() > 50)
    {
        approxPolyDP(contours[i], approxShape, cv::arcLength(cv::Mat(contours[i]), true)*0.04, true);
        drawContours(drawing, contours, i, cv::Scalar(255, 0, 0), 0);

        std::vector<Point> newObject;

        for(size_t j = 0; j < contours[i].size(); j++)
        {
            cv::Point newPoint = contours[i][j];    
            newObject.push_back(Point((float) newPoint.x / 100, 0.0f,(float) newPoint.y / 100));
        }

        pointList.push_back(newObject);
    }
}

ObjectCreator3D::createObjects(&pointList);
contours.clear();

<code to release images, etc>
}

这将捕获图像，检索对象的坐标，然后调用ObjectCreator3D::createObjects()：

void ObjectCreator3D::createObjects(std::list<std::vector<Point>>* inputList)
{
std::list<WorldObject>* tempObjects = new std::list<WorldObject>;

for(std::vector<Point>&pointObject : *inputList)
{                       
    WorldObject worldObject(&pointObject);
    tempObjects->push_back(worldObject);
}

DataStorage::getInstance()->setObjects(tempObjects);
}

所有对象都转换为WorldObjects：

#include <list>
#include <iostream>
#include <GL/glut.h>
#include <GL/freeglut.h>
#include <time.h>

#include "WorldObject.h"
#include "Point.h"

//Constant height - adjustable/randomized solution is partially implemented in the     constructor.
const float WorldObject::HEIGHT = 5.0f;

template <class C> void FreeClear(C & cntr)
{
for(typename C::iterator it = cntr.begin(); it != cntr.end(); ++it)
{
    delete * it;
}
cntr.clear();
}

WorldObject::WorldObject(std::vector<Point>* pointList)
{
//TODO, when we have time. Seems difficult because height will change each update...
/*srand (time(NULL));
float fGeneratedY = (rand() % 20 + 2) / 2.0f;*/

cdt = nullptr;

for (Point &point : *pointList) 
    //point.setY(fGeneratedY);
    point.setY(HEIGHT);

this->pointList = pointList;
}

WorldObject::~WorldObject()
{
//Cleanup
delete cdt;
FreeClear(polyPoints);
}

/*
Author Tim Cocu & Bas Rops
Function for drawing the WorldObject
*/
void WorldObject::draw()
{
glPushMatrix();

glColor3f(0.8f, 0.8f, 0.8f);

//Calculate our bottom pane
calculateTriangles();

//BOTTOM PANE
for (unsigned int i = 0; i < calculatedTriangles.size(); i++)
{
    p2t::Triangle& t = *calculatedTriangles[i];
    p2t::Point& a = *t.GetPoint(0);
    p2t::Point& b = *t.GetPoint(1);
    p2t::Point& c = *t.GetPoint(2);

    glBegin(GL_TRIANGLES);
        glNormal3f(0, -1, 0);
        glVertex3f((GLfloat)a.x, (GLfloat)0.0f, (GLfloat)a.y);
        glVertex3f((GLfloat)b.x, (GLfloat)0.0f, (GLfloat)b.y);
        glVertex3f((GLfloat)c.x, (GLfloat)0.0f, (GLfloat)c.y);
    glEnd();
}

//TOP PANE
for (unsigned int i = 0; i < calculatedTriangles.size(); i++)
{
    p2t::Triangle& t = *calculatedTriangles[i];
    p2t::Point& a = *t.GetPoint(0);
    p2t::Point& b = *t.GetPoint(1);
    p2t::Point& c = *t.GetPoint(2);

    glBegin(GL_TRIANGLES);
        glNormal3f(0, 1, 0);
        glVertex3f((GLfloat)a.x, (GLfloat)HEIGHT, (GLfloat)a.y);
        glVertex3f((GLfloat)b.x, (GLfloat)HEIGHT, (GLfloat)b.y);
        glVertex3f((GLfloat)c.x, (GLfloat)HEIGHT, (GLfloat)c.y);
    glEnd();
}

glColor3f(1.0f, 1.0f, 1.0f);

//SIDE PANES
for(std::size_t iPaneCounter = 0; iPaneCounter < pointList->size(); iPaneCounter++)
{
    Point firstPoint = (*pointList)[iPaneCounter];
    Point secondPoint (0.0f, 0.0f, 0.0f);

    if(iPaneCounter + 1 < pointList->size())
        secondPoint.set((*pointList)[iPaneCounter + 1].getX(), (*pointList)[iPaneCounter + 1].getY(), (*pointList)[iPaneCounter + 1].getZ() );
    else
        secondPoint.set((*pointList)[0].getX(), (*pointList)[0].getY(), (*pointList)[0].getZ());

    glBegin(GL_POLYGON);
        float fNormalX = (firstPoint.getY() * secondPoint.getZ()) - (firstPoint.getZ() * secondPoint.getY());
        float fNormalY = -((secondPoint.getZ() * firstPoint.getX()) - (secondPoint.getX() * firstPoint.getZ()));
        float fNormalZ = (firstPoint.getX() * secondPoint.getY()) - (firstPoint.getY() * secondPoint.getX());
        glNormal3f(fNormalX, fNormalY, fNormalZ);

        glVertex3f(firstPoint.getX(), 0.0f, firstPoint.getZ());
        glVertex3f(secondPoint.getX(), 0.0f, secondPoint.getZ());
        glVertex3f(secondPoint.getX(), secondPoint.getY(), secondPoint.getZ());
        glVertex3f(firstPoint.getX(), firstPoint.getY(), firstPoint.getZ());
    glEnd();
}
}

/*
Calculates triangles that make a ground or top pane. Used for calculating possible     non-convex objects
*/
void WorldObject::calculateTriangles()
{
//Empty the polyPoints list
if(polyPoints.size() > 0)
    FreeClear(polyPoints);

//Convert our Points to p2t::Points
for(std::size_t iBottomIndex = 0; iBottomIndex < pointList->size(); iBottomIndex++)
    polyPoints.push_back(new p2t::Point((*pointList)[iBottomIndex].getX(), (*pointList)[iBottomIndex].getZ()));

if(cdt == nullptr)
    //Create CDT (Constrained Delaunay Triangulation) and add primary polyPoints
    //NOTE: polyPoints must be a simple polygon. The polyPoints' points constitute constrained edges. No repeating points are allowed!
    cdt = new p2t::CDT(polyPoints);

//Turn our polyPoints into p2t::Triangles
cdt->Triangulate();

//Set the triangles to use for drawing
calculatedTriangles = cdt->GetTriangles();
}

/*
Retrieve a pointer to a list of Points
*/
std::vector<Point>* WorldObject::getPoints()
{
return pointList;
}

/*
Retrieve a pointer to a list of p2t::Triangles
*/
std::vector<p2t::Triangle*> WorldObject::getCalculatedTriangles()
{
return calculatedTriangles;
}

创建所有实例后，将它们存储在DataStorage中，调用DataStorage：：WorldObjects ()->setObjects()：

void DataStorage::setObjects(std::list<WorldObject>* objectList)
{
delete this->objectList;
this->objectList = objectList;
}

应用程序似乎在删除setObjects()中的delete this->objectList；时崩溃，所以我们认为应用程序试图删除他无法删除的内容。

任何帮助都将不胜感激，我们已经研究了几天了

Answer 1

在这里，您将指向列表所拥有的对象的指针传递给WorldObject的构造函数

for(std::vector<Point>&pointObject : *inputList)
{                       
  WorldObject worldObject(&pointObject);
  tempObjects->push_back(worldObject);
}

在WorldObject中，您可以存储指针：

//Default Constructor
WorldObject::WorldObject(std::vector<Point>* pointList)
{
  float fGeneratedY = (rand() % 20 + 2) / 2.0f;*/

  cdt = nullptr;

  for (Point &point : *pointList) 
    point.setY(HEIGHT);

  this->pointList = pointList;
}

这意味着，只要构造WorldObjects的std::list还存在，WorldObject::pointList就是有效的。(在那之后，结果是不确定的--它可以工作，它可能崩溃，它可能格式化你的硬盘，并将你的身份泄露给德克萨斯州)。

如果您坚持使用原始指针，那么作为程序员，您有责任检查和跟踪每个指针的生命周期。这很容易出错，并且会导致随机的崩溃，你会发现很难追踪到。

停止使用原始指针。相反，如果对象拥有资源，则将其存储在std::unique_ptr<>中。如果您希望同一资源由多个对象共享，请使用std::shared_ptr和std::weak_ptr，除非这些对象中只有一个对象的生命周期比其他对象的生命周期短得多，这是有保证的。