insertar una cadena en una lista

[Cardo2095]

quisiera saber como puedo insertar una cadena de caracteres en una lista en c++, intente de esta forma pero me da un error con la dirección de memoria a la hora de insertar la cadena

Código PHP:

  void main(){

Lista <char> *l1;
char cad[50];
int tam;

    
    cout << "Escriba la Notacion Infija a Convertir en Prefija" << endl;
    cin >> cad;
    tam = strlen(cad);

    for (int i = 0; i <= tam;i++){
        l1->Insertar(cad[i]);//aqui me tira un error con la variable cad[i]
    }
}  
   

este es el metodo de insertar que tengo:

Código PHP:

template <class T>
void Lista <T>::Insertar(T *pDato){
 
    Nodo<T>* nodo = new Nodo<T>(pDato);
    actual = primero;
 
    if (Vacio()){
        primero = nodo;
    }
 
    else{
        while (actual->getSig()){
            actual = actual->getSig();
        }
        actual->setSig(nodo);
    }
 
}
 

[eferion]

Código C++:

Lista <char> *l1;
 

l1 es un puntero a un objeto de tipo Lista<char>... dónde creas el objeto?? en ningún sitio. Al no crear el objeto, el puntero (que tampoco está inicializado), "apunta" a una dirección de memoria no válida, por lo que al intentar realizar la operación "l1->Insertar(cad[i])" el programa va a dar error.

Para solucionar este problema tienes dos opciones:

1. Quitas el asterisco, usas el objeto por valor, lo cual implica que se creará y se destruirá automáticamente. Por supuesto, al usar el objeto por valor, ya no puedes usar el operador '->'.

2. Usas un new por algún lado para inicializar el objeto... y luego, por supuesto, te faltaría el correspondiente delete para liberar la memoria reservada.

Un saludo.

[Cardo2095]

de hecho ya lo hice jeje pero aun hay algo que me inquieta a la hora de imprimir la cadena o nose si sera que es asi por ejemplo si ingreso asd me imprime: asd,sd,d
como que me va eliminando la primera letra y lo que quiero es que me quede de esta forma: a,s,d

Código PHP:

  void main{ 
Lista <char> l1; 
 
    char cad[50]; 
    int tam; 
 
    cout << "Escriba la Notacion Infija a Convertir en Prefija" << endl; 
    gets_s(cad); 
    tam = strlen(cad); 
 
    for (int i = 0; i <= tam;i++){ 
        l1.Insertar(&cad[i]); 
    } 
 
    l1.ImprimeLista(); 
    system("pause"); 
}  
   

[eferion]

Si no publicas el código de Lista<T> y de Nodo<T> es complicado ayudarte

[Cardo2095]

Iniciado por Cardo2095

de hecho ya lo hice jeje pero aun hay algo que me inquieta a la hora de imprimir la cadena o nose si sera que es asi por ejemplo si ingreso asd me imprime: asd,sd,d
como que me va eliminando la primera letra y lo que quiero es que me quede de esta forma: a,s,d

Clase Nodo

Código PHP:

  template<class T>
class Nodo{

private:
    T * elemento;
    Nodo <T> * sig;

public:
    Nodo <T>(T *);

    ~Nodo <T>();
    void setElemento(T*);
    T * getElemento();
    void setSig(Nodo <T> *);
    Nodo <T> * getSig();
};



//-----------------------------------IMPLEMENTACIÓN-------------------------------------------------------


template<class T>
Nodo<T>::~Nodo(){}

template<class T>
Nodo <T>::Nodo(T * pElem){
    elemento = pElem;
    sig = NULL;
}

template<class T>
void Nodo <T>::setElemento(T* Elem){
    elemento = Elem;
}

template<class T>
T* Nodo <T>::getElemento(){
    return elemento;
}

template<class T>
void Nodo <T>::setSig(Nodo <T> * pSig){
    sig = pSig;
}

template<class T>
Nodo<T> * Nodo <T>::getSig(){
    return sig;
}  
   

Clase Lista

Código PHP:

  #include"Nodo.h"
#include<iostream>
#include<fstream>
using namespace std;


template<class T>
class Lista{

private:
    Nodo <T>* primero;
    Nodo <T>* actual;

public:
    Lista();
    ~Lista();


    void setactual(Nodo<T>*);
    void setprimero(Nodo<T>*);

    Nodo<T>* getActual();
    Nodo<T>* getPrimero();

    void Insertar(T *pDato);
    void ImprimeLista();
    T* Buscar(int id);
    void Eliminar(T *k);
    bool Existencia(int id);
    bool Vacio() const;

};


//-----------------------------------IMPLEMENTACIÓN-------------------------------------------------------

template <class T>
Lista<T>::Lista()
{
    primero = actual= NULL;
}

template <class T>
Lista<T>::~Lista()
{
}

//-----------------------------------------------------------------------------------

template<class T>
void Lista<T>::setactual(Nodo<T>*n){
    actual = n;
}

template<class T>
void Lista<T>::setprimero(Nodo<T>*n){
    primero = n;
}

template<class T>
Nodo<T>* Lista<T>::getActual(){
    return actual;
}

template<class T>
Nodo<T>* Lista<T>::getPrimero(){
    return primero;
}

//-----------------------------------------------------------------------------------

template <class T>
void Lista <T>::Insertar(T *pDato){

    Nodo<T>* nodo = new Nodo<T>(pDato);
    actual = primero;

    if (Vacio()){
        primero = nodo;
    }

    else{
        while (actual->getSig()){
            actual = actual->getSig();
        }
        actual->setSig(nodo);
    }

}

template <class T>
void Lista<T>::ImprimeLista(){
    system("cls");
    
    actual = primero;

    if (actual == NULL) {
        cout << "La lista esta vacia" << endl;
    }

    else{
        while (actual != NULL){
            cout<< actual->getElemento()<< endl;
            
            actual = actual->getSig();
        }
    }
    
}

template <class T>
T* Lista<T>::Buscar(int id)
{
    Nodo<T>* anterior = NULL;
    actual = primero;
    while ((actual != NULL) && (actual->getElemento()->getId() != id)){
        anterior = actual;
        actual = actual->getSig();
    }
    if (actual->getElemento()->getId() == id)
    {
        return actual->getElemento();
    }
    else return false;
}



template <class T>
void Lista<T>::Eliminar(T *k){//borra uno en especifico
    Nodo<T>* anterior = NULL;
    actual = primero;
    while (actual && actual->getElemento()->getId() != k->getId()){
        anterior = actual;
        actual = actual->getSig();
    }
    if (!actual || actual->getElemento()->getId() != k->getId())
        cout << "No encontro el elemento";
    else{
        if (!anterior){
            primero = actual->getSig();
        }
        else{
            anterior->setSig(actual->getSig());
        }
    }
    delete actual;
}

template <class T>
bool Lista<T>::Existencia(int id){
    actual = primero;
    while (actual != NULL){
        if (actual->getElemento()->getId() == id){ return true; }
        actual = actual->getSig();
    }
    return false;
}

template <class T>
bool Lista<T>::Vacio() const{
    return (primero == NULL);
}  
   

Código PHP:

  void main{
Lista <char> l1;

    char cad[50];
    int tam;

    cout << "Escriba la Notacion Infija a Convertir en Prefija" << endl;
    gets_s(cad);
    tam = strlen(cad);

    for (int i = 0; i <= tam;i++){
        l1.Insertar(&cad[i]);
    }

    l1.ImprimeLista();
    system("pause");
}  
   

[eferion]

Para no hablar en plan genérico, voy a particularizar los templates. Te permitirá entender mejor el problema.

• Nodo<char> almacena un char*, es decir, un puntero a char.
• Lista<char>::Insertar( ) recibe un char*
• Al imprimir la lista haces:
  Código C++:

  cout<< actual->getElemento()<< endl;
   

  es decir, estás imprimiendo un char*. Da la casualidad que char* es el tipo utilizado por las cadenas de caracteres... luego cout va a volcar caracteres por pantalla hasta que se encuentre con el primer caracter nulo. Da la casualidad también que no has añadido los caracteres a la lista, sino que has añadido su posición en memoria... por algo almacenas punteros. El caso es que los punteros de Nodo<char> apuntan directamente a la cadena original... luego al volcar el char* te va a imprimir el contenido original de la cadena, pero empezando por el caracter que corresponda.

Soluciones... veo dos posibles:

Solución chapucera

Cambias el cout de Lista<T>::ImprimeLista para que luzca tal que:

Código C++:

cout<< *actual->getElemento()<< endl;
 

De esta forma no estarás volcando un char*, sino simplemente un char

Solución buena

Lo suyo sería modificar los templates. El comportamiento que yo esperaría de un template tipo Nodo<T> es que si yo creo un Nodo<char>, esta estructura trabaje con el tipo char, no con el tipo char*... si resulta que necesito trabajar con char* entonces crearé una estructura tal que Nodo<char*>. Este cambio de concepto te permitirá crear templates más consistentes y versátiles.

Por supuesto además de Nodo<T> también tendrás que modificar Lista<T> para que deje de usar punteros T* sin venir a cuento. Es una solución más laboriosa pero a la vez más limpia y, por supuesto, es la solución que yo te recomiendo.

Un saludo.