C/Visual C - Dudas sobre apuntadores...

Dudas sobre apuntadores...

Publicado por gerardo (2 intervenciones) el 04/04/2003 03:50:20

Hmmm.... tengo algunas dudas sobre apuntadores.. espero me puedan ayudar :)
Estoy utilizando apuntadores y tal parecen que tengo un problema relacionado con la memoria porque cuando corro el programa me sale el error de Win2K de que la memoria en cierta posicion no se puede leer.

Supongamos que tengo una clase llamada CShape que contiene informacion acerca de una forma geometrica y tambien contiene 2 apuntadores (uno a next, y otro a prev).

Cual es la diferencia entre los 2 metodos siguientes:

(En donde copyFrom es un apuntador al primer nodo de la lista que va a ser copiada, y copyTo es un apuntador al primer nodo de la lista a donde van a ser copiados todos los nodos).

=======================================
VOID CGraphics::CopyListFrom(CShape* copyFrom, CShape *copyTo)
{
CShape *newNode, *aux, *originalList;

aux=copyFrom;
originalList=copyTo;
assert(aux!=NULL);
assert(originalList!=NULL);

while((originalList->Get_Next())!=NULL)
originalList=originalList->Get_Next();

while((aux->Get_Next())!=NULL){
aux=aux->Get_Next();
newNode = new CShape;
// copiar todos los datos desde aux
newNode->Set_Next(NULL);
newNode->Set_Prev(originalList);
originalList->Set_Next(newNode);
newNode=NULL;
originalList=originalList->Get_Next();
}
}
=======================================
y el siguien

Valora esta pregunta

Me gusta: Está pregunta es útil y esta clara

No me gusta: Está pregunta no esta clara o no es útil

Responder

Dudas sobre apuntadores y copia de listas en C++

Publicado por Alejandro (1153 intervenciones) el 13/05/2025 19:17:33

Gerardo, entiendo que estás teniendo problemas con el manejo de apuntadores y la memoria en tu implementación de la clase `CShape`. Vamos a analizar el código que proporcionaste y a responder tus preguntas sobre la diferencia entre los dos métodos.

Análisis del método `CopyListFrom`

El método `CopyListFrom` tiene como objetivo copiar una lista enlazada de nodos de tipo `CShape` desde un nodo de origen (`copyFrom`) a un nodo de destino (`copyTo`). Aquí hay algunos puntos clave a considerar:

1. Inicialización de apuntadores:

- `aux` se inicializa con `copyFrom`, que es el nodo de origen.
- `originalList` se inicializa con `copyTo`, que es el nodo de destino.

2. Afirmaciones:

- Se utilizan `assert` para asegurarse de que ambos apuntadores no sean nulos. Esto es una buena práctica para evitar errores de acceso a memoria.

3. Recorrido de la lista de destino:

- El primer `while` recorre la lista de destino (`originalList`) hasta encontrar el último nodo (donde `Get_Next()` es `NULL`).

4. Copia de nodos:

- El segundo `while` recorre la lista de origen (`aux`) y crea nuevos nodos en la lista de destino.
- Se asigna memoria para un nuevo nodo con `new CShape`.
- Se copian los datos desde `aux` al nuevo nodo.
- Se establece el puntero `next` del nuevo nodo a `NULL` y el puntero `prev` al último nodo de la lista de destino.
- Se actualiza el puntero `next` del último nodo de la lista de destino para apuntar al nuevo nodo.

Problemas potenciales

1. Acceso a memoria no válida:

- Si `copyFrom` o `copyTo` son nulos o si `copyFrom` no contiene nodos válidos, el programa puede intentar acceder a memoria no válida, lo que causará el error que mencionas.

2. Finalización de la lista:

- En el segundo `while`, el bucle termina cuando `aux->Get_Next()` es `NULL`, pero no se está copiando el último nodo de la lista de origen. Deberías copiar el nodo actual (`aux`) antes de avanzar al siguiente.

3. Asignación de `newNode` a `NULL`:

- La línea `newNode = NULL;` no es necesaria y puede causar confusión. Después de crear un nuevo nodo, deberías seguir utilizando `newNode` para establecer las conexiones.

Diferencia entre los métodos

Aunque no proporcionaste dos métodos específicos para comparar, aquí hay una posible interpretación de lo que podrías estar preguntando:

- Método 1: Copia solo los punteros de la lista de origen a la lista de destino, sin crear nuevos nodos. Esto puede llevar a problemas de memoria, ya que ambos punteros apuntarían a la misma dirección de memoria.

- Método 2: Crea nuevos nodos en la lista de destino, como lo hace tu implementación actual. Esto es más seguro, ya que cada lista tiene su propia copia de los nodos, evitando problemas de acceso a memoria.

Corrección del código

Aquí hay una versión corregida del método `CopyListFrom`:

VOID CGraphics::CopyListFrom(CShape* copyFrom, CShape *copyTo)

    CShape *newNode, *aux, *originalList;

    aux = copyFrom;

    originalList = copyTo;

    assert(aux != NULL);

    assert(originalList != NULL);

    // Mover al final de la lista de destino

    while (originalList->Get_Next() != NULL) {

        originalList = originalList->Get_Next();

    // Copiar nodos de la lista de origen a la lista de destino

    while (aux != NULL) { // Cambiar a aux != NULL para incluir el último nodo

        newNode = new CShape;

        // Copiar todos los datos desde aux

        newNode->Set_Data(aux->Get_Data()); // Asegúrate de tener un método para copiar datos

        newNode->Set_Next(NULL);

        newNode->Set_Prev(originalList);

        originalList->Set_Next(newNode);

        // Avanzar en ambas listas

        originalList = newNode; // Ahora originalList apunta al nuevo nodo

        aux = aux->Get_Next(); // Avanzar en la lista de origen

Conclusión

Asegúrate de que todos los punteros estén correctamente inicializados y que no accedas a memoria no válida. La corrección del bucle de copia asegurará que todos los nodos se copien correctamente. Si sigues teniendo problemas, revisa el manejo de memoria y asegúrate de que no haya fugas de memoria o accesos indebidos.

Valora esta respuesta

Me gusta: Está respuesta es útil y esta clara

No me gusta: Está respuesta no esta clara o no es útil

Comentar