Los datos variables de C ++ se sobrescriben
https://stackoverflow.com/questions/1233361
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Han pasado algunos años desde que escribí C / C ++, y ahora me enfrento a un problema que parece que no puedo resolver por mi cuenta.
Dada la siguiente estructura:
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;
}
};
Comienzo definiendo una serie de nodos y su relación padre / hijo:
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;
Tenga en cuenta que i5 como el único nodo no tiene hijos.
Luego paso a hacer un trabajo utilizando estos datos (llamando a BuildMeshVertices (& amp; i0, & amp; vértices) desde main ()), y termino agregando un hijo a i5:
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);
}
}
Después de lo cual todo está bien. i0 tiene un hijo (i1), i1 tiene un hijo (i2), etc., y ahora i5 también tiene un hijo.
Llamo a otra función (BuildMeshIndices ()), y de repente unas pocas líneas en esta función (línea 63) se sobrescriben los datos para el niño recién agregado a i5. i5 todavía apunta al niño correcto, pero los datos de este niño de repente están confusos.
Aquí hay una captura de pantalla antes y después (perdón por el enlace, pero no estaba permitido usar etiquetas IMG)
No puedo entender por qué sucede esto, pero tengo la sensación de que tiene algo que ver con mi mala gestión de la memoria.
ACTUALIZACIÓN Además, no tiene que hacerse de esta manera. Si, por ejemplo, cambiar el vector secundario a un vector de valores es la forma preferida de C ++, preferiría eso. Intenté comentar las respuestas, pero no estoy seguro de que ustedes estén viendo los comentarios (de acuerdo con las preguntas frecuentes, necesitan 50 reputación para dejar comentarios).
A continuación se muestra el código fuente completo (con todo lo innecesario eliminado, pero suficiente para reproducir el error):
#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;
}
Solución
Cambie los punteros sin formato a punteros inteligentes y obtendrá problemas de gestión de memoria.
No necesita copiar todo el impulso a su proyecto, solo los encabezados requeridos.
#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;
}
Cree que todavía tiene un código sucio medio C, medio C ++ ... debería elegir un idioma.
Otros consejos
Está empujando el puntero hacia un objeto de pila en su vector. Una vez que la ejecución deja el alcance, ese objeto de pila se destruirá y la memoria se reutilizará, lo que dará como resultado un valor falso. Probar
InputData *iDeadEnd = new InputData(1.01f, 0.5f);
iDeadEnd->deadEnd = true;
iDeadEnd->parent = current;
current->children.push_back(iDeadEnd);
Entonces tendrás que liberar esa memoria en el momento apropiado.
Debe usar memoria dinámica para trabajar con punteros. InputData se destruirá cuando salga de la función BuildMeshVertices , por lo que los datos serán basura o obtendrá una excepción de memoria.
Deberías hacer algo como
InputData * iDeadEnd = new InputData(1.01f, 0.5f);
en lugar de
InputData iDeadEnd = InputData(1.01f, 0.5f);
¡Estás instalando iDeadEnd en el STACK y tomando un puntero a la dirección del stack! Cuando las funciones finalizan y la pila se desenrolla, los datos de iDeadEnd se van a confundir.
InputData *iDeadEnd = new InputData(1.01f, 0.5f);
iDeadEnd->deadEnd = true;
iDeadEnd->parent = current;
current->children.push_back(iDeadEnd);
BuildMeshVertices(iDeadEnd, vertices);
El problema que tiene ahora es que la memoria para iDeadEnd debe ser desasignada explícitamente cuando haya terminado con ella.
En el momento en que se cierra la función BuildMeshVertices, iDeadEnd (hijo de i5) se deconstruye porque lo declaró en la pila y al salir de la función se invalida todo el marco de la pila y se deconstruyen todos los objetos. Desea asignar dinámicamente iDeadEnd o repensar radicalmente cómo define un árbol. Sería mejor que cada estructura contenga un vector de InputData (no InputData *) y luego los configure de la siguiente manera:
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.
Incluso eso está lejos de ser ideal por razones obvias. Definir un árbol de elementos nunca es lo más divertido de hacer.
