[SOLUCIONADO] Generar un numero variable de nodos para una lista

[tyrax]

Buenas noches, disculpen la molestia. Me encuentro realizando un algoritmo que lee una serie de datos de un archivo, los almacena en objetos de una clase que he creado, y luego esos objetos van a una lista.

Ahora, el problema que tengo es que el numero de objetos que debo crear es algo que viene dado en archivo que leo. No se como crear la cantidad de nodos necesaria, ya que no siempre la cantidad de objetos para agregar en la lista sera igual.

He pensado que quiza podria agregar a mi algoritmo la habilidad de agregar nodos mediante el nombre de una variable. Por ejemplo, si tengo una cadena de caracteres llamada "nombre" y que contenga "nodo1" como valor inicial, y fuera cambiando el nombre de la variable cada vez que necesite crear un nodo (nodo1, nodo2, nodo3...). Pero no se si pueda hacerse algo como esto...

Código C++:

string nombre = "nodo1"; //Ir cambiando este valir a medida que avanza el algoritmo
nodo nombre; //El valor de nodo tendria que ser nodo1, que es lo que contiene la variable nombre
 

Les muestro parte de mi codigo, sinceramente no se trabajar bien con listas y a esto es a lo que he podido llegar hasta ahora. Si existe una forma de enlazar cada nodo a su siguiente sin hacer lo que se me ocurrio en principio, estaria inmensamente agradecido con su ayuda. El archivo Datos.txt contiene un numero en su primera linea, que indica el numero de objetos que tendre, y luego la lista de objetos, uno por linea.

Código C++:

using namespace std;
class cosa {
    public:
        string nombre;
 
        cosa(){ //Constructor
        nombre = "default";
            }
};
 
struct Nodo{ //Nodo
    cosa G1;
    struct Nodo *sig, *ant;
};
struct Nodo *inicio, *final;
 
int main(){
        int cantidad=0;
    int comodin3;
    int operaciones;
    string comodin1;
    char comodin2[1000];
    
    struct Nodo *sujetos;
    sujetos=new(struct Nodo);
    
    ifstream archivo;
    archivo.open("datos.txt");
            if (archivo == NULL){
                cout << "El archivo no existe \n" << endl;
                exit (EXIT_FAILURE);
            }else{  
    
        archivo.getline(comodin2, 1000, '\n'); //Lectura de numero de objetos
        cantidad = atoi(comodin2);
 
            for (int i=0; i<cantidad; i++){
            
            archivo.getline(comodin2, 1000, '\n'); //Lectura de nombre
            sujetos->G1.nombre = comodin2;
            
//
//  Por aca tendria que agregar el objeto al nodo y enlazar al siguiente
//  Por aca tendria que agregar el objeto al nodo y enlazar al siguiente
//  Por aca tendria que agregar el objeto al nodo y enlazar al siguiente
//  Por aca tendria que agregar el objeto al nodo y enlazar al siguiente
//  Por aca tendria que agregar el objeto al nodo y enlazar al siguiente
//
            
        }
    archivo.close();
    }
}
 

Podrian darme una solucion que me permita agregar ese objeto al nodo y agregar a un siguiente nodo? Ya sea creando uno nuevo o no.

PD: El codigo original es mucho mas largo, he editado todo lo que he podido para hacerlo lo mas legible y sencillo posible, asi que es posible que encuentren por alli alguna variable no declarada o alguna funcion que no existe. Disculpen por el post tan largo.

[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

[tyrax]

vosk, muchas gracias por tu respuesta! Creo que esto es justo lo que necesitaba. Ir creando nodos enlazados al anterior sin tener que crearlos manualmente.

En este momento no puedo intentar implementar tu codigo, ya que voy saliendo a la universidad, pero en unas horas cuando llegue a casa lo intentare!

Estare haciendote saber como va mi algoritmo

[vosk]

Ok, una ultima cosa, omití algunas cosas pero tendrias que implementarlas para hacer una aplicacion correcta; p.ej. la funcion que añade el nodo podría ser boleana, de forma que si no puede reservar memoria para la nueva struct retorna 1 (o 0 da igual), en cuyo caso tendrias que liberar la clase COSA creada previamente con 'crea_cosa'. Todas las comprovaciones de error tienen que estar resueltas para cada condicion: sin error sigue la aplicacion, con error libera los recursos, reporta el error y cierra o reinicia el ciclo.

Revisa lo que te comente de los vectores, creo que te será mas facil de implementar.

Saludos
vosk

[tyrax]

Bueno vosk, ya el algoritmo esta terminado. Funciona a la perfeccion, y aunque encontre algunas cosas mas que no sabia como hacer en el camino, esta listo. Muchas gracias por tu ayuda en verdad.