Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Retornar string en C++

Estas en el tema de Retornar string en C++ en el foro de C/C++ en Foros del Web. Hola soy nuevo en el foro, muy bueno el foro la verdad, me arrepiento de no haber entrado antes, bueno tengo un problema, estoy haciendo ...
  #1 (permalink)  
Antiguo 12/05/2012, 22:01
 
Fecha de Ingreso: mayo-2012
Mensajes: 1
Antigüedad: 11 años, 10 meses
Puntos: 0
Retornar string en C++

Hola soy nuevo en el foro, muy bueno el foro la verdad, me arrepiento de no haber entrado antes, bueno tengo un problema, estoy haciendo un programa y tengo un error en la siguiente funcion:

string recursivo(string pal,Pila *p,Cola *c, int i )
{
if((!p->pilavacia() )|| i<pal.length() )
{
if((pal[i]!=' ') && (pal[i]!=',') && (pal[i]!='.'))
{
if(p->tope()==c->tope())
pal[i]='-';
p->desapilar();
c->desencolar();
}
recursivo(pal,p,c,++i);
}
else
{
return pal;
}

el problema se presenta cunado retorno "pal", me da error en ejecucion... antes la funcion "recursivo" era void y dentro del "else" habia un cout, y mostraba "pal", asi funcionaba muy bien, pero necestio que retorne el string... como antes de moficiar eso funcionaba a la perfeccion, puedo suponer que error esta dentro de la funcion anterior, especificamente cunado retorno "pal"
alguien sabe porque es el error en ejecucion?...

El programa entero esta aca:


Código:
#include <cstdlib>
#include <iostream>
#include <sstream>

using namespace std;

void iterativa(string);
//string recursivo(string,Pila *,Cola * );

typedef int tipolista;

class Nodo{
    protected: 
        tipolista dato;
        Nodo *next;
    public:
        Nodo() {next=NULL;};
        Nodo(tipolista a) {dato=a; next=NULL;};
        void set_dato(tipolista a) {dato=a; };
        void set_next(Nodo *n) {next=n; };
        tipolista get_dato() {return dato; };
        Nodo *get_next() {return next; };
        bool es_vacio() {return next==NULL;};
        
};

class Lista{
    protected: Nodo *czo;
    public:
            Lista() {czo=new Nodo();};
            Lista(Nodo *n) {czo=n;};
            void del(void);
            void add(tipolista d);
            bool esvacia(void);
            tipolista cabeza(void);
            Lista *resto(void);
            string toPrint(tipolista p);   
            Nodo *get_czo(void){return czo;}
};

void Lista::del(void)
{    Nodo *aux;
     aux=czo;
     czo=czo->get_next();
     delete aux;
}
void Lista::add(tipolista d)
{  
     Nodo *nuevo=new Nodo(d);
     nuevo->set_next(czo);
     czo=nuevo;
}
bool Lista::esvacia(void)
{   
    return czo->es_vacio();
}

tipolista Lista::cabeza(void)
{ 
  if(esvacia()){
                cout<<" Error, Cabeza de lista vacia";
                return -1; 
  }
  return czo->get_dato();
}

Lista *Lista::resto(void)
{ 
      Lista *l=new Lista(czo->get_next());
      return (l);
}

string Lista::toPrint(tipolista p)
{ 
     if (this->esvacia()) {
        return "";
     } else {
       std::ostringstream stm;
       stm << this->cabeza()<<"-"<< this->resto()->toPrint(p) << endl;
       return stm.str();
     }
}

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

class Cola{
      private:
              Lista *l;
              Nodo *czoq;
              void update_start(Lista *l,Nodo *p);
              void do_desencolar(Nodo *p,Nodo *s);
      public:
      Cola(void){l=new Lista();update_start(l,NULL);};
      ~Cola(void) {delete(l);};
      int tope();
      int colavacia() { return l->esvacia();};
      void encolar(int a) ;
      void desencolar();
};

int Cola::tope() {
           if (colavacia()){
              cout<<"Error: Cola vacia"<<endl;
              return -1;
           } 
           else
              return czoq->get_dato();
}

void Cola::encolar(int a) 
{
     l->add(a);
     if (czoq==NULL) {
        update_start(l,czoq);
     }
}

void Cola::desencolar() {
           if (colavacia())
              cout<<"Error: Cola vacia"<<endl;
           else {
              do_desencolar(l->get_czo(),NULL);
              update_start(l,NULL);
           }
}

void Cola::do_desencolar(Nodo *p,Nodo *s){
     if (p->get_next()==NULL) {
         if (s!=NULL) {
            s->set_next(NULL);
         }
         delete(p);
     }else {
         this->do_desencolar(p->get_next(),p);
     }
}
void Cola::update_start(Lista *l,Nodo *p){
     if (l->esvacia()) {
          czoq=p;
     }else {
          this->update_start(l->resto(),l->get_czo());
     }
}


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

class Pila:public Lista{
      public:
             Pila(){Lista();};
             void apilar(tipolista x){add(x);};
             tipolista tope(void){return cabeza();};
             void desapilar(void){del();};
             bool pilavacia(){return esvacia();};
             
}; 


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

void iterativa(string pal)

{
   Cola *l=new Cola();
   Pila *p=new Pila();
      for(int i=0; i<pal.length();i++) // LLena la cola y la pila
         { 
             if((pal[i]!=' ') && (pal[i]!=',') && (pal[i]!='.'))
               {        
                p->apilar(pal[i]);
                l->encolar(pal[i]);
               }
                
                  
               
         }    
      
      for(int i=0;  i<pal.length() ;i++) // Compara los datos de la pila con los de las cola, y arma el nuevo string
        {    
              
              if((pal[i]!=' ') && (pal[i]!=',') && (pal[i]!='.'))
            
               {
                               if(p->tope()==l->tope())
                                     pal[i]='-';
                                     p->desapilar();
                                     l->desencolar();
               }
        }
            
cout<<endl<<"El palindromo por ITERATIVIDAD ES: " << pal << endl;                
                            

}







string recursivo(string,Pila *,Cola *,int );

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

string recursivo(string pal,Pila *p,Cola *c, int i )

{
     if((!p->pilavacia() )|| i<pal.length() )
         {      
                if((pal[i]!=' ') && (pal[i]!=',') && (pal[i]!='.'))
                       {
                             if(p->tope()==c->tope())
                             pal[i]='-';
                             p->desapilar();
                             c->desencolar();
                       }
                                
                 recursivo(pal,p,c,++i);
                       
         }
      else
           {
               
               return pal; 
           }       
}
//---------------------------------------------------------------------







int main()

{
   string palin="neuquen";
   Cola *ci=new Cola();
   Pila *pi=new Pila();
   string NUEVO;
//cout<<endl<<"Ingrese cadena= "; cin>>palin;   
  for(int i=0; i<palin.length();i++)
         {
             if((palin[i]!=' ') && (palin[i]!=',') && (palin[i]!='.'))
              {  
             pi->apilar(palin[i]);
             ci->encolar(palin[i]);
              }
         }
         
         


cout<<"LA FRASE = "<<palin<<endl;
cout<<endl<<endl<<"//////////////////////////////////////////////////////////"<<endl<<endl;
iterativa(palin);
cout<<endl<<endl<<"//////////////////////////////////////////////////////////"<<endl<<endl;


NUEVO = recursivo(palin,pi,ci,0);

cout<<endl<<"El palindromo por RECURSIVIDAD ES: " << NUEVO << endl; 

cout<<endl<<endl;

system("PAUSE");


}

EDITO: ENCONTRE LA SOLUCION, me falto un return antes de llamar de nuevo a la funcion, osea quedaria return recursivo(pal,p,c,++i); ... que manera de perder tiempo con esto jaja

Última edición por rosalva40; 13/05/2012 a las 00:18

Etiquetas: funcion, int, programa, retornar, string
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta




La zona horaria es GMT -6. Ahora son las 02:32.