调整大小时std :: vector和内存错误

Question

I have a structure defined like this:

struct Edge
{
    int u, v;   // vertices

    Edge() { }
    Edge(int u, int v)
    {
        this->u = u;
        this->v = v;
    }
};

and a class field defined like

vector<Edge> solution;

In one of the methods I'm creating new Edge s and pushing them into the vector like this (a huge simplification of my real code, but the problem still exists):

solution.push_back(Edge(1, 2));
solution.push_back(Edge(3, 4));
solution.push_back(Edge(5, 6));
solution.push_back(Edge(7, 8));
solution.push_back(Edge(9, 10));
solution.push_back(Edge(11, 12));
solution.push_back(Edge(13, 14)); // adding 7th element; the problem occurs here

When the last push_back is executing, I'm getting an error window in Visual Studio's debug mode

[AppName] has triggered a breakpoint.

and the debugger goes to malloc.c , to the end of _heap_alloc function. Before this 7th line, the vector seems to work properly. I can see all the elements in the debugger. It seems that the vector has a problem reallocating itself (expanding its size).

What's interesting, if I put this before all the pushing back:

solution.reserve(7);

, the 7th edge is added properly. What's even more interesting, trying to reserve space for more than 22 elements also causes the mentioned error.

What am I doing wrong? How can I debug it? The rest of the application doesn't use so much memory, so I can't believe the heap is full.

---

More code, on request. It's a rather sloppy implementation of 2-approximation algorithm for Metric Travelling Salesman's Problem. It first creates a minimum spanning tree, then adds vertices (just indices) to the partialSolution vector in the DFS order.

void ApproxTSPSolver::Solve()
{
    // creating a incidence matrix
    SquareMatrix<float> graph(noOfPoints);

    for (int r=0; r<noOfPoints; r++)
    {
        for (int c=0; c<noOfPoints; c++)
        {
            if (r == c)
                graph.SetValue(r, c, MAX);
            else
                graph.SetValue(r, c, points[r].distance(points[c]));
        }
    }

    // finding a minimum spanning tree
    spanningTree = SquareMatrix<bool>(noOfPoints);

    // zeroeing the matrix
    for (int r=0; r<noOfPoints; r++)
        for (int c=0; c<noOfPoints; c++)
            spanningTree.SetValue(r, c, false);

    bool* selected = new bool[noOfPoints];
    memset(selected, 0, noOfPoints*sizeof(bool));
    selected[0] = true; // the first point is initially selected

    float min;
    int minR, minC;

    for (int i=0; i<noOfPoints - 1; i++)
    {
        min = MAX;

        for (int r=0; r<noOfPoints; r++)
        {
            if (selected[r] == false)
                continue;

            for (int c=0; c<noOfPoints; c++)
            {
                if (selected[c] == false && graph.GetValue(r, c) < min)
                {
                    min = graph.GetValue(r, c);
                    minR = r;
                    minC = c;
                }
            }
        }

        selected[minC] = true;
        spanningTree.SetValue(minR, minC, true);
    }

    delete[] selected;

    // traversing the tree
    DFS(0);

    minSol = 0.0f;

    // rewriting the solution to the solver's solution field
    for (int i=0; i<noOfPoints - 1; i++)
    {
        solution.push_back(Edge(partialSolution[i], partialSolution[i + 1]));
        minSol += points[partialSolution[i]].distance(points[partialSolution[i + 1]]);
    }

    solution.push_back(Edge(partialSolution[noOfPoints - 1], partialSolution[0]));
    minSol += points[partialSolution[noOfPoints - 1]].distance(points[partialSolution[0]]);

    cout << endl << minSol << endl;

    solved = true;
}

void ApproxTSPSolver::DFS(int vertex)
{
    bool isPresent = std::find(partialSolution.begin(), partialSolution.end(), vertex)
        != partialSolution.end();

    if (isPresent == false)
        partialSolution.push_back(vertex); // if I comment out this line, the error doesn't occur

    for (int i=0; i<spanningTree.GetSize(); i++)
    {
        if (spanningTree.GetValue(vertex, i) == true)
            DFS(i);
    }
}


class ApproxTSPSolver : public TSPSolver
{
    vector<int> partialSolution;
    SquareMatrix<bool> spanningTree;
    void DFS(int vertex);

public:
    void Solve() override;
};

---

from main.cpp :

TSPSolver* solver;
    string inputFilePath, outputFilePath;

    // parsing arguments
    if (ArgParser::CmdOptionExists(argv, argv + argc, "/a"))
    {
        solver = new ApproxTSPSolver();
    }
    else if (ArgParser::CmdOptionExists(argv, argv + argc, "/b"))
    {
        solver = new BruteForceTSPSolver();
    }
    else
    {
        solver = new BranchAndBoundTSPSolver();
    }

    inputFilePath = ArgParser::GetCmdOption(argv, argv + argc, "/i");
    outputFilePath = ArgParser::GetCmdOption(argv, argv + argc, "/s");

    solver->LoadFromFile(inputFilePath);

    Timer timer;
    timer.start();
    solver->Solve();
    timer.stop();

    cout << timer.getElapsedTime();

A part of TSPSolver.c:

TSPSolver::TSPSolver()
{
    points = NULL;
    solved = false;
}

TSPSolver::~TSPSolver()
{
    if (points)
        delete[] points;
}

void TSPSolver::LoadFromFile(string path)
{
    ifstream input(path);
    string line;
    int nodeID;
    float coordX, coordY;
    bool coords = false;

    minX = numeric_limits<float>::max();
    maxX = numeric_limits<float>::min();
    minY = numeric_limits<float>::max();
    maxY = numeric_limits<float>::min();

    while (input.good())
    {
        if (coords == false)
        {
            getline(input, line);

            if (line == "NODE_COORD_SECTION")
            {
                coords = true;
            }
            else if (line.find("DIMENSION") != string::npos)
            {
                int colonPos = line.find_last_of(":");
                noOfPoints = stoi(line.substr(colonPos + 1));
#ifdef _DEBUG
                cout << noOfPoints << " points" << endl;
#endif

                // allocating memory for this amount of points
                points = new Point[noOfPoints];
            }
        }
        else
        {
            input >> nodeID >> coordX >> coordY;

            points[nodeID - 1].X = coordX;
            points[nodeID - 1].Y = coordY;

            minX = min(minX, coordX);
            maxX = max(maxX, coordX);
            minY = min(minY, coordY);
            maxY = max(maxY, coordY);

            if (nodeID == noOfPoints)
            {
                break;
            }
        }
    }

    input.close();
}

Answer 1

This is rather a comment then an answer, but the space is too limited.

If you are on windows, try Microsoft Application Verifier . It might detect wrong memory access.

Another way of detecting such access is to reseve empty char arrays initialized to 0.

Open your class where the vector is declared and declare a char array of let's say 64 chars before and after your vector and initialize them to 0!. Then break into your vector code, where the error is generated and check the contents of those padding arrays. If they are filled, somebody writes more that it should.

A way to locate the "malicious" access (at least in VC++) is to set a data breakpoint writing in your padding arrays and check the callstack then.

Answer 2

You may be doing out-of-bounds accesses on points in various places, eg this one:

input >> nodeID >> coordX >> coordY;
points[nodeID - 1].X = coordX;

What if input failed, or the value is out of range?

I would suggest removing all uses of new and delete and [] from your code; eg assuming points is int *points; then replace it with std::vector<int> points . Change all [] accesses to be .at() and catch exceptions. Disable copying on all classes that don't have correct copy semantics.

Then you can be more certain that it is not a memory allocation error, copying error, or out-of-bounds access (which are strong candidates for explaining your symptoms).

This would also fix the problem that TSPSolver currently does not have correct copy semantics.

It would be very useful to make a SSCCE. You mention that there is "a lot of input", try reducing the input as small as you can but still have the problem occur. An SSCCE can include input data so long as it is a manageable size that you can post. Currently you show too much code but not enough, as they say. The problem is still lurking somewhere you haven't posted yet.