Generar un numero variable de nodos para una lista

[vosk]

Puede que no me quede clara tu duda, pero me parece que lo que buscas es ir añadiendo los nuevos nodos como siguiente del anterior. Algo asi:

- creas un nodo inicial
- creas un segundo nodo y lo añades como siguiente del primero
- creas un tercer nodo y lo añades como siguiente del segundo
- etc

Es lo que sería una lista simple; en tu codigo tienes una lista doble, es decir, que cada nodo apunta a su anterior y a su siguiente; si el anterior el primero apunta al ultimo y el siguiente del ultimo apunta al primero entonces tienes una lista circular. No se si ya te suena de algo todo esto.

Te propongo un ejemplo de lista simple para ver como añadir nodos al final:

Código C++:

class COSA {
public:
    void set_name(string name) {
        this->name = name;
    }
    string get_name() {
        return this->name;
    }
 
private:
    string name;
};
 
 
typedef struct tagNodo{
    class COSA *cosa;
    struct tagNodo *sig;
} Nodo;
 
 
class COSA *crea_cosa(string nombre) {
    class COSA *cosa = 0;
 
    if((cosa = new(nothrow) class COSA)) {
        cosa->set_name(nombre);
    }
 
    return cosa;
}
 
 
void add_cosa(Nodo **lista, class COSA *cosa) {
    Nodo *nuevo_nodo, *ptr;
 
    if((nuevo_nodo = new(nothrow) Nodo)) {
        nuevo_nodo->cosa = cosa;
        nuevo_nodo->sig = 0;
 
        if(!(ptr = *lista)) {
            *lista = nuevo_nodo;
        }
        else {
            while(ptr->sig) {
                ptr = ptr->sig;
            }
            ptr->sig = nuevo_nodo;
        }
    }
}
 
 
void muestra_cosas(Nodo *lista) {
    Nodo *ptr;
 
    ptr = lista;
    while(ptr) {
        cout << ptr->cosa->get_name() << endl;
        ptr = ptr->sig;
    }
}
 
 
void libera_cosas(Nodo **lista) {
    Nodo *ptr, *sig;
 
    ptr = *lista;
    while(ptr) {
        sig = ptr->sig;
        delete ptr->cosa;
        delete ptr;
 
        ptr = sig;
    }
    *lista = 0;
}
 
 
int main() {
    Nodo *lista_de_cosas;
    COSA *ptr;
 
    lista_de_cosas = 0;
 
    ptr = crea_cosa("una");
    add_cosa(&lista_de_cosas, ptr);
    ptr = crea_cosa("prueba");
    add_cosa(&lista_de_cosas, ptr);
    ptr = crea_cosa("de");
    add_cosa(&lista_de_cosas, ptr);
    ptr = crea_cosa("texto");
    add_cosa(&lista_de_cosas, ptr);
 
    muestra_cosas(lista_de_cosas);
    libera_cosas(&lista_de_cosas);
 
    return 0;
}
 

Tal como ves puedo seguir añadiendo hasta que se agote la memoria. Hay algunas cosas importantes a tener en cuenta: hacer las comprovaciones de error para el caso de que no haya memoria disponible. En el ejemplo estoy usando new(nothrow) para que no me arroje excepciones y validar directamente el retorno contra nulo (nulo si no hay memoria disponible). Otra cosa importante es iniciar los elementos nulos como nulos (no recuerdo si c++ no hace por defecto, pero es mejor asegurarse), es el caso de la lista_de_cosas, quiero que inicialmente sea nula para que la funcion de añadir entienda que a la primera llamada le envio una lista nula; lo mismo para los punteros 'sig' que hay en la estructura, que antes de ser rellenados con un nodo siguiente quiero que sean nulos. Una ultima cosa, para cada new necesitas un delete, es lo que hago en la funcion de liberar_cosas; en los pc actuales esto de liberar la memoria dinamica solo tiene sentido cuando quieres reutilizar en la misma ejecucion la misma variable para mas de una lista, pero es una buena practica liberar la memoria reservada y por eso te lo pongo.

Otra cosa, ya que estas en c++ porque no usas un contenedor tipo vector o list para hacer estas listas? Te resultará mas fácil y seguramente tendras menos fallos. COn eso te ahorras el trabajo con structs, que en tu ejemplo parece ser que solo las usas para soportar los punteros siguiente y anterior. Tambien puedes separar el manejador de listas en una nueva clase: una clase que se encargará de manejar la lista.

Saludos
vosk