C++-Variablendaten werden überschrieben

StackOverflow https://stackoverflow.com/questions/1233361

Frage

Es ist schon ein paar Jahre her, seit ich C/C++ geschrieben habe, und jetzt stehe ich vor einem Problem, das ich scheinbar alleine nicht lösen kann.

Angesichts der folgenden Struktur:

struct InputData
{
    float diameter;
    float length;
    int vertIndex;
    struct InputData *parent;
    vector<InputData*> children;
    bool deadEnd;

    InputData(float dia, float lngth)
    {
        diameter = dia;
        length = lngth;
        vertIndex = NULL;
        parent = NULL;
        deadEnd = false;
    }
};

Ich beginne damit, eine Reihe von Knoten und ihre Eltern-/Kindbeziehung zu definieren:

InputData i0 = InputData(3.0f, 3.0f);
InputData i1 = InputData(2.0f, 2.0f);
InputData i2 = InputData(1.0f, 1.0f);
InputData i3 = InputData(1.0f, 1.0f);
InputData i4 = InputData(1.0f, 1.0f);
InputData i5 = InputData(1.01f, 0.5f);

i0.children.push_back(&i1);
i1.children.push_back(&i2);
i2.children.push_back(&i3);
i3.children.push_back(&i4);
i4.children.push_back(&i5);

i1.parent = &i0;
i2.parent = &i1;
i3.parent = &i2;
i4.parent = &i3;
i5.parent = &i4;

Beachten Sie, dass i5 als einziger Knoten keine untergeordneten Knoten hat.

Anschließend mache ich einige Arbeiten mit diesen Daten (Aufruf von BuildMeshVertices(&i0, &vertices) von main()) und füge am Ende ein untergeordnetes Element zu i5 hinzu:

void BuildMeshVertices(InputData* current, vector<SimpleVertex> *vertices)
{
    //Do work

    if(current->children.size() == 1)
    {
        BuildMeshVertices(current->children[0], vertices);
    }
    else if(current->children.size() == 0 && current->deadEnd == false)
    {
        InputData iDeadEnd = InputData(1.01f, 0.5f);
        iDeadEnd.deadEnd = true;
        iDeadEnd.parent = current;
        current->children.push_back(&iDeadEnd);     

        BuildMeshVertices(&iDeadEnd, vertices);
    }
}

Danach ist alles in Ordnung.i0 hat ein Kind (i1), i1 hat ein Kind (i2) usw. und i5 hat jetzt auch ein Kind.

Ich rufe eine andere Funktion (BuildMeshIndices()) auf und plötzlich werden ein paar Zeilen in dieser Funktion (Zeile 63) die Daten für das neu hinzugefügte untergeordnete Element zu i5 überschrieben.i5 zeigt immer noch auf das richtige Kind, aber die Daten für dieses Kind sind plötzlich verstümmelt.

Hier ist ein Screenshot vorher und nachher (Entschuldigung für den Link, aber ich durfte keine IMG-Tags verwenden)

Ich kann nicht herausfinden, warum das passiert, aber ich habe das Gefühl, dass es etwas mit meiner schlechten Speicherverwaltung zu tun hat?

AKTUALISIEREN Es muss auch nicht so gemacht werden.Wenn zum Beispiel die Änderung des Kindervektors in einen Wertevektor die bevorzugte C++-Methode ist, würde ich das deutlich vorziehen.Ich habe versucht, die Antworten zu kommentieren, bin mir aber nicht sicher, ob ihr die Kommentare seht (laut FAQ benötigt ihr 50 Reputationen, um Kommentare zu hinterlassen)?

Unten finden Sie den vollständigen Quellcode (ohne alles Unnötige, aber genug, um den Fehler zu reproduzieren):

#include "stdafx.h"
#include <vector>

using std::vector;

struct InputData
{
    float diameter;
    float length;
    int vertIndex;
    struct InputData *parent;
    vector<InputData*> children;
    bool deadEnd;

    InputData(float dia, float lngth)
    {
        diameter = dia;
        length = lngth;
        vertIndex = NULL;
        parent = NULL;
        deadEnd = false;
    }
};

//--------------------------------------------------------------------------------------
// Vertex types
//--------------------------------------------------------------------------------------
struct SimpleVertex
{
    float Pos;

    SimpleVertex(float Position)
    {
        Pos = Position;
    }
};

void BuildMeshVertices(InputData* current, vector<SimpleVertex> *vertices)
{
    current->vertIndex = vertices->size();

    //Add vertices..

    if(current->children.size() == 1)
    {
        BuildMeshVertices(current->children[0], vertices);
    }
    else if(current->children.size() == 0 && current->deadEnd == false)
    {
        InputData iDeadEnd = InputData(1.01f, 0.5f);
        iDeadEnd.deadEnd = true;
        iDeadEnd.parent = current;
        current->children.push_back(&iDeadEnd);     

        BuildMeshVertices(&iDeadEnd, vertices);
    }
}

void BuildMeshIndices(InputData* current, vector<unsigned long> *indices)
{
    indices->push_back(current->vertIndex+2);
    indices->push_back(current->vertIndex+0);
    indices->push_back(current->vertIndex+1);
    indices->push_back(current->vertIndex+3);
    indices->push_back(current->vertIndex+0);
    indices->push_back(current->vertIndex+2);

    InputData *parent = current->parent;

    unsigned long vOffset;

    if(parent != NULL && parent->children.size() == 1)
    {   
        vOffset = (unsigned long)current->vertIndex;

        indices->push_back(vOffset+7);
        indices->push_back(vOffset+5);
        indices->push_back(vOffset+4);
        indices->push_back(vOffset+6);
        indices->push_back(vOffset+5);
        indices->push_back(vOffset+7);

        indices->push_back(vOffset+10);
        indices->push_back(vOffset+8);
        indices->push_back(vOffset+9);
        indices->push_back(vOffset+11);
        indices->push_back(vOffset+8);
        indices->push_back(vOffset+10);

        indices->push_back(vOffset+15);
        indices->push_back(vOffset+13);
        indices->push_back(vOffset+12);
        indices->push_back(vOffset+14);
        indices->push_back(vOffset+13);
        indices->push_back(vOffset+15);

        indices->push_back(vOffset+18);
        indices->push_back(vOffset+16);
        indices->push_back(vOffset+17);
        indices->push_back(vOffset+19);
        indices->push_back(vOffset+16);
        indices->push_back(vOffset+18);
    }

    if(current->children.size() == 1 && current->deadEnd == false)
    {
        BuildMeshIndices(current->children[0], indices);
    }
}

int _tmain(int argc, _TCHAR* argv[])
{
    InputData i0 = InputData(3.0f, 3.0f);
    InputData i1 = InputData(2.0f, 2.0f);
    InputData i2 = InputData(1.0f, 1.0f);
    InputData i3 = InputData(1.0f, 1.0f);
    InputData i4 = InputData(1.0f, 1.0f);
    InputData i5 = InputData(1.01f, 0.5f);

    i0.children.push_back(&i1);
    i1.children.push_back(&i2);
    i2.children.push_back(&i3);
    i3.children.push_back(&i4);
    i4.children.push_back(&i5);

    i1.parent = &i0;
    i2.parent = &i1;
    i3.parent = &i2;
    i4.parent = &i3;
    i5.parent = &i4;

    // Create vertex buffer
    vector<SimpleVertex> vertices;

    BuildMeshVertices(&i0, &vertices);

    // Create index buffer
    vector<unsigned long> indices;

    BuildMeshIndices(&i0, &indices);

    return 0;
}
War es hilfreich?

Lösung

roh Zeiger ändern href="http://www.boost.org/doc/libs/1_39_0/libs/smart_ptr/shared_ptr.htm" rel="nofollow noreferrer"> intelligente Zeiger

Sie brauchen nicht alle Impulse für Ihr Projekt zu kopieren, nur erforderlich Header. 

#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

struct InputData
{
    float diameter;
    float length;
    unsigned long vertIndex;
    boost::weak_ptr<InputData> parent;
    std::vector< boost::shared_ptr<InputData> > children;
    bool deadEnd;

    InputData(float dia, float lngth, boost::weak_ptr<InputData> p = boost::weak_ptr<InputData>(), bool de = false)
        : diameter(dia), length(lngth), vertIndex(0), parent(p), deadEnd(de) {}
};

struct SimpleVertex
{
    float Pos;

    SimpleVertex(float position) : Pos(position) {}
};

void BuildMeshVertices(boost::shared_ptr<InputData> current, std::vector<SimpleVertex>& vertices)
{
    current->vertIndex = vertices.size();

    //Add vertices..
    if(current->children.size() == 1)
    {
        BuildMeshVertices(current->children[0], vertices);
    }
    else if(current->children.size() == 0 && current->deadEnd == false)
    {
          // this was a stack variable, so the pointer became invalid when going out of ambit.
        boost::shared_ptr<InputData> iDeadEnd( new InputData(1.01f, 0.5f, current, true) );
        current->children.push_back(iDeadEnd);         

        BuildMeshVertices(iDeadEnd, vertices);
    }
}

void BuildMeshIndices(boost::shared_ptr<InputData> current, std::vector<unsigned long>& indices)
{
    unsigned long vi = current->vertIndex;
    unsigned long  ioffset[] = { vi+2, vi, vi+1, vi+3, vi, vi+2};
    indices.insert(indices.end(), ioffset, ioffset+6);

    boost::shared_ptr<InputData> parent = current->parent.lock();
    if (parent && parent->children.size() == 1)
    {   
        unsigned long offs = current->vertIndex;
          unsigned long voffset[] = 
          { offs+7, offs+5, offs+4, offs+6, offs+5, offs+7,
            offs+10, offs+8, offs+9, offs+11, offs+8, offs+10,
            offs+15, offs+13, offs+12, offs+14, offs+13, offs+15,
            offs+18, offs+16, offs+17, offs+19, offs+16, offs+18 };
          indices.insert(indices.end(), voffset, voffset+24);
    }

    if(current->children.size() == 1 && current->deadEnd == false)
    {
        BuildMeshIndices(current->children[0], indices);
    }
}

int main()
{
    boost::shared_ptr<InputData> i0( new InputData(3.0f, 3.0f) );
    boost::shared_ptr<InputData> i1( new InputData(2.0f, 2.0f) );
    boost::shared_ptr<InputData> i2( new InputData(1.0f, 1.0f) );
    boost::shared_ptr<InputData> i3( new InputData(1.0f, 1.0f) );
    boost::shared_ptr<InputData> i4( new InputData(1.0f, 1.0f) );
    boost::shared_ptr<InputData> i5( new InputData(1.01f, 0.5f) );

    i0->children.push_back(i1);
    i1->children.push_back(i2);
    i2->children.push_back(i3);
    i3->children.push_back(i4);
    i4->children.push_back(i5);

    i1->parent = i0;
    i2->parent = i1;
    i3->parent = i2;
    i4->parent = i3;
    i5->parent = i4;

    // Create vertex buffer
    std::vector<SimpleVertex> vertices;
    BuildMeshVertices(i0, vertices);

    // Create index buffer
    std::vector<unsigned long> indices;
    BuildMeshIndices(i0, indices);

    return 0;
}

Denken Sie immer noch eine Hälfte haben C, C ++ Hälfte schmutzigen Code ... Sie sollten eine Sprache wählen.

Andere Tipps

Sie haben den Zeiger auf einen Stapel Objekt in den Vektor. Sobald die Ausführung läßt Raum, dass Objekt-Stack erhalten zerstört und der Speicher wird wieder verwendet wird, in einem falschen Wert ergibt. Versuchen 

InputData *iDeadEnd = new InputData(1.01f, 0.5f);
iDeadEnd->deadEnd = true;
iDeadEnd->parent = current;
current->children.push_back(iDeadEnd);

Dann werden Sie, dass der Speicher zu gegebener Zeit befreien müssen.

Sie sollten dynamischen Speicher verwenden, um mit Zeigern zu arbeiten. Eingabedaten wird zerstört, wenn Sie die Funktion verlassen BuildMeshVertices, sodass die Daten vernichtet werden oder Sie eine Speicherausnahme erhalten.

Du solltest so etwas tun

InputData * iDeadEnd = new InputData(1.01f, 0.5f);

anstatt

InputData iDeadEnd = InputData(1.01f, 0.5f);

Sie sind Instancing iDeadEnd auf dem Stapel, und einen Zeiger auf die Stapeladresse nehmen! Wenn die Funktionen beenden und der Stapel abwickelt, werden die Daten für iDeadEnd gehen verstümmeln. 

InputData *iDeadEnd = new InputData(1.01f, 0.5f);
iDeadEnd->deadEnd = true;
iDeadEnd->parent = current;
current->children.push_back(iDeadEnd);         

BuildMeshVertices(iDeadEnd, vertices);

Das Problem, das Sie jetzt haben, ist, dass der Speicher für iDeadEnd werden muss explizit freigegeben, wenn Sie mit ihm fertig sind.

In dem Moment, Ihre BuildMeshVertices Funktion tritt dann iDeadEnd (i5 Kind) dekonstruiert wird, weil Sie es auf dem Stapel deklariert und durch die Funktion der gesamte Stack-Frame Verlassen ungültig gemacht wird und alle Objekt dekonstruiert. Sie wollen entweder dynamisch iDeadEnd zuweisen oder radikal neu denken, wie man einen Baum definieren. Sie wären besser dran, die jeweils einen Vektor von Inputdata halten Struktur (nicht Inputdata *) und Setzen sie dann wie folgt: 

InputData i0 = InputData(3.0f, 3.0f);
i0.children.push_back( InputData( 2.0f, 2.0f ) );
i0.children[0].children.push_back( InputData( 1.0f, 1.0f ) );

etc

Auch das ist bei weitem nicht ideal aus offensichtlichen Gründen. nie der Spaß der Dinge ist ein Baum von Elementen definiert, obwohl zu tun.

Nicht verbunden mit StackOverflow
scroll top