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

Duda con programa que gestiona ITV

Estas en el tema de Duda con programa que gestiona ITV en el foro de C/C++ en Foros del Web. Hola soy estudiante de ingenieria informática y tengo una duda con una práctica que nos han mandado. La práctica consiste en la simulación de gestión ...
  #1 (permalink)  
Antiguo 28/04/2016, 14:09
 
Fecha de Ingreso: abril-2016
Mensajes: 3
Antigüedad: 8 años, 6 meses
Puntos: 0
Duda con programa que gestiona ITV

Hola soy estudiante de ingenieria informática y tengo una duda con una práctica que nos han mandado. La práctica consiste en la simulación de gestión de una ITV con colas y demás. Ya la tengo casi finalizada y al final pide una simulación automática pero cuando en una cola queda un vehículo y este es OK me da error y bloquea el programa. Podéis echarle un vistazo por favor? No se si es por que llevo todo el dia con esto pero no encuentro el fallo Ruborizado .

Gracias de antemano y un saludo!!

Código C++:
Ver original
  1. #include <cstdlib>
  2. #include <iostream>
  3. #include<time.h>
  4.  
  5.  
  6. using namespace std;
  7.  
  8.  
  9. typedef struct vehiculo
  10. {
  11.     string matricula;
  12.     bool estado ;
  13.     char tipo;
  14.     string marca;
  15.     string modelo;
  16.     struct vehiculo *sig;
  17.    
  18.    
  19. };
  20. typedef struct Cola
  21. {
  22.     struct vehiculo *cabecera;
  23.     struct vehiculo *ultimo;   
  24. }*lacola;
  25.  
  26.  
  27. lacola crearCola(void)
  28. {
  29.    
  30.    
  31.     lacola co= new struct Cola;
  32.    
  33.     co->cabecera = new struct vehiculo;
  34.     co->ultimo = new struct vehiculo;
  35.    
  36.     co->ultimo = NULL;
  37.     co->cabecera->sig = NULL;
  38.    
  39.     return co;
  40. }
  41.  
  42. bool colaVacia(lacola laco)
  43. {
  44.     if(laco->ultimo == NULL)
  45.     return true;
  46.     else
  47.     return false;  
  48. }
  49.  
  50. void crearMatricula (string &matricula){
  51.  
  52.     char nmatricula[8];
  53.     string numeros="0123456789";
  54.     string letrasma="BCFGHJKLMNPRSTVWXYZ";
  55.  
  56.     for(int i=0;i<4;i++)
  57.     {
  58.         nmatricula[i]=numeros[rand() %numeros.length()];
  59.     }
  60.     for(int i=4;i<7;i++)
  61.     {
  62.         nmatricula[i]=letrasma[rand() %letrasma.length()];
  63.     }
  64.     nmatricula[7] = '\0';
  65.     matricula = string(nmatricula);
  66.  
  67. }
  68.  
  69. void anyadir(lacola laco)
  70. {
  71.     struct vehiculo *nodo_aux;
  72.    
  73.     nodo_aux = new struct vehiculo;
  74.    
  75.     if(colaVacia(laco))
  76.     {
  77.        
  78.         crearMatricula(nodo_aux->matricula);
  79.         nodo_aux->sig = NULL;
  80.         laco->cabecera->sig = nodo_aux;
  81.         laco->ultimo = nodo_aux;   
  82.     }      
  83.     else
  84.     {
  85.         crearMatricula(nodo_aux->matricula);
  86.         nodo_aux->sig = NULL;
  87.         laco->ultimo->sig = nodo_aux;  
  88.         laco->ultimo = nodo_aux;
  89.     }
  90. }
  91. void quitar(lacola laco)
  92. {
  93.     string resul;
  94.     struct vehiculo *nodo_aux;
  95.     if(colaVacia(laco))
  96.     {
  97.         cout << "LA COLA ESTA VACIA" << endl;
  98.        
  99.     }
  100.     else
  101.     {
  102.         if(laco->cabecera->sig == laco->ultimo)
  103.         {
  104.             resul = laco->cabecera->sig->matricula;
  105.             laco->cabecera->sig=NULL;
  106.             laco->ultimo=NULL;
  107.             delete (laco->cabecera->sig);
  108.         }
  109.         else
  110.         {
  111.             resul= laco->cabecera->sig->matricula;
  112.             nodo_aux = laco->cabecera->sig;
  113.             laco->cabecera->sig = laco->cabecera->sig->sig;
  114.             delete (nodo_aux);
  115.         }
  116.     }
  117.    
  118. }
  119. string primeroCola(lacola laco)
  120. {
  121.     string x;
  122.     if(colaVacia(laco))
  123.     {
  124.         cout << "LA COLA ESTA VACIA" << endl<<endl;
  125.         return x;
  126.        
  127.     }
  128.     else
  129.         cout<<laco->cabecera->sig->matricula;
  130.         return laco->cabecera->sig->matricula;     
  131. }
  132.  
  133. void completarColas(lacola laco)
  134. {
  135.     struct vehiculo *nodo_aux;
  136.     nodo_aux = new struct vehiculo;
  137.     nodo_aux = laco->cabecera->sig;
  138.     int i =0;
  139.     int j = 5;
  140.    
  141.     while(nodo_aux!=NULL)
  142.     {
  143.         i++;
  144.         nodo_aux = nodo_aux->sig;  
  145.        
  146.     }
  147.    
  148.     j=j-i;
  149.    
  150.     while(j!=0)
  151.     {
  152.        
  153.         anyadir(laco);
  154.         j--;
  155.     }
  156.      
  157. }
  158. bool estado(string h)
  159. {
  160.  
  161.  
  162.     int a;
  163.     a= rand() % 10 + 1;
  164.     if(a<8)
  165.         return true;
  166.    
  167.     else
  168.         return false;
  169.    
  170.    
  171. }
  172. void volver(lacola laco)
  173. {
  174.     struct vehiculo *nodo_aux;
  175.     nodo_aux = new struct vehiculo;
  176.     nodo_aux = laco->cabecera->sig;
  177.     laco->cabecera->sig = nodo_aux->sig;
  178.     laco->ultimo->sig = nodo_aux;
  179.     nodo_aux->sig = NULL;
  180.     laco->ultimo = nodo_aux;
  181.    
  182. }
  183. void ver(lacola laco)
  184. {
  185.     struct vehiculo *nodo_aux;
  186.    
  187.     nodo_aux = new struct vehiculo;
  188.     nodo_aux = laco->cabecera->sig;
  189.     while (nodo_aux!=NULL)
  190.     {
  191.         cout << " " << nodo_aux->matricula <<" ";
  192.         nodo_aux = nodo_aux->sig;
  193.     }  
  194.  
  195. }
  196. void simulacion(lacola laco)
  197. {  
  198.    
  199.    
  200.     cout<<"El estado del vehiculo con matricula  ";
  201.     if(estado(primeroCola(laco)) ==  true)
  202.     {
  203.         cout<<" es OK, por lo tanto abandona la cola."<<endl;
  204.         quitar(laco);
  205.         cout<<endl;
  206.         ver(laco);
  207.         cout<<endl;
  208.     }
  209.     else
  210.     {
  211.          cout<<" es KO,por lo tanto vuelve al final de la cola."<<endl;
  212.          volver(laco);
  213.          cout<<endl;
  214.          ver(laco);
  215.          cout<<endl;
  216.          
  217.  
  218.     }
  219.        
  220.    
  221.    
  222. }
  #2 (permalink)  
Antiguo 28/04/2016, 14:10
 
Fecha de Ingreso: abril-2016
Mensajes: 3
Antigüedad: 8 años, 6 meses
Puntos: 0
Respuesta: Duda con programa que gestiona ITV

el Main


Código C++:
Ver original
  1. int main(int argc, char *argv[])
  2. {
  3.     lacola gasolina, diesel, moto, industrial;
  4.    
  5.     gasolina=crearCola();
  6.     diesel =crearCola();
  7.     moto = crearCola();
  8.     industrial = crearCola();
  9.    
  10.     char i;
  11.     int j;
  12.    
  13.     cout<<"********************************************************************************************"<<endl;
  14.     cout<<"***************************************Colas ITV********************************************"<<endl;
  15.     cout<<"********************************************************************************************"<<endl;
  16.     cout<<"Elige una opcion: "<<endl;
  17.     do
  18.     {
  19.         cout<<"\tA. Poner un vehiculo en cualquier cola: G, D, M, I."<<endl;
  20.         cout<<"\tB. Sacar de la cola el primer vehiculo de cualquier cola: G, D, M, I."<<endl;
  21.         cout<<"\tC. Imprimir cualquier cola: G, D, M, I."<<endl;
  22.         cout<<"\tD. Consultar que vehiculo esta esperando cualquier cola: G, D, M, I."<<endl;
  23.         cout<<"\tE. Iniciar la simulacion."<<endl;
  24.         cout<<"\tF. Salir de la aplicacion."<<endl;
  25.        
  26.        
  27.        
  28.         cin>> i;
  29.         cout<<endl;
  30.  
  31.         switch(i)
  32.         {
  33.             case'A':
  34.                
  35.                 do{
  36.                
  37.                     do{
  38.                    
  39.                         cout<<"Elige un vehiculo:G(gasolina),D(diesel),M(moto),I(industrial)"<<endl;
  40.                         cin >> i;
  41.                         cout<<endl;
  42.                         switch(i)
  43.                         {
  44.                             case'G':
  45.                                 anyadir(gasolina);
  46.                                 break;
  47.                             case'D':
  48.                                 anyadir(diesel);
  49.                                 break;
  50.                             case'M':
  51.                                 anyadir(moto);
  52.                                 break;
  53.                              case'I':
  54.                                 anyadir(industrial);
  55.                                 break;
  56.                             default:
  57.                                  cout<<"Elige una opcion correcta"<<endl;
  58.                         }
  59.                  
  60.                     }while(i!='G' && i!='D' && i!='M' && i!='I' );
  61.                    do{
  62.                         cout<<"¿Desea poner otro vehiculo en cola? S(Si), N(No)"<<endl;
  63.                         cin>>i;
  64.                         cout<<endl;
  65.                         if(i!='S' && i!='N')
  66.                         {
  67.                              cout<<"Elige una opcion correcta"<<endl;
  68.                            
  69.                         }
  70.                     }while(i!='S' && i!='N');
  71.                    
  72.                 }while(i=='S');
  73.                 break;
  74.                
  75.                    
  76.             case'B':
  77.                   do{
  78.                
  79.                     do{
  80.                    
  81.                         cout<<"Elige un vehiculo para quitar de la cola:G(gasolina),D(diesel),M(moto),I(industrial)"<<endl;
  82.                         cin >> i;
  83.                         cout<<endl;
  84.                         switch(i)
  85.                         {
  86.                             case'G':
  87.                                 quitar(gasolina);
  88.                                 break;
  89.                             case'D':
  90.                                 quitar(diesel);
  91.                                 break;
  92.                             case'M':
  93.                                 quitar(moto);
  94.                                 break;
  95.                              case'I':
  96.                                 quitar(industrial);
  97.                                 break;
  98.                             default:
  99.                                  cout<<"Elige una opcion correcta"<<endl;
  100.                         }
  101.                         break;
  102.                     }while(i!='G' && i!='D' && i!='M' && i!='I' );
  103.                    do{
  104.                         cout<<"¿Desea quitar otro vehiculo en cola? S(Si), N(No)"<<endl;
  105.                         cin>>i;
  106.                         cout<<endl;
  107.                         if(i!='S' && i!='N')
  108.                         {
  109.                              cout<<"Elige una opcion correcta"<<endl;
  110.                            
  111.                         }
  112.                     }while(i!='S' && i!='N');
  113.                    
  114.                 }while(i=='S');
  115.                            
  116.                
  117.                 break;
  118.                
  119.             case'C':
  120.                  do{
  121.                
  122.                     do{
  123.                    
  124.                         cout<<"Elige la cola de vehiculos que deseas ver:G(gasolina),D(diesel),M(moto),I(industrial)"<<endl;
  125.                         cin >> i;
  126.                         cout<<endl;
  127.                         switch(i)
  128.                         {
  129.                             case'G':
  130.                                 ver(gasolina);
  131.                                
  132.                                 break;
  133.                             case'D':
  134.                                 ver(diesel);
  135.                                 break;
  136.                             case'M':
  137.                                 ver(moto);
  138.                                 break;
  139.                              case'I':
  140.                                 ver(industrial);
  141.                                 break;
  142.                             default:
  143.                                  cout<<"Elige una opcion correcta"<<endl;
  144.                         }
  145.                         break;
  146.                     }while(i!='G' && i!='D' && i!='M' && i!='I');
  147.                    do{
  148.                         cout<<"¿Desea ver otra cola de vehiculos? S(Si), N(No)"<<endl;
  149.                         cin>>i;
  150.                         cout<<endl;
  151.                         if(i!='S' && i!='N')
  152.                         {
  153.                              cout<<"Elige una opcion correcta"<<endl;
  154.                            
  155.                         }
  156.                     }while(i!='S' && i!='N');
  157.                    
  158.                 }while(i=='S');
  159.                 break;
  160.                
  161.             case'D':
  162.                 primeroCola(gasolina);
  163.                
  164.                 break;
  165.                
  166.             case'E':
  167.                 completarColas(gasolina);
  168.                 completarColas(diesel);
  169.                 completarColas(moto);
  170.                 completarColas(industrial);
  171.                
  172.                 while(colaVacia(gasolina)== false || colaVacia(diesel)== false || colaVacia(moto)== false || colaVacia(industrial)== false){
  173.                         j=rand() %4 + 1;
  174.                         switch(j)
  175.                         {
  176.                             case 1:
  177.                                 if(colaVacia(gasolina)== false){
  178.                                 cout<<"Cola gasolina: "; ver(gasolina); cout<<endl;
  179.                                 simulacion(gasolina);
  180.                                 cout<<endl;
  181.                                 }  
  182.                                
  183.                                 break;
  184.                                
  185.                             case 2:
  186.                                  if(colaVacia(diesel)== false){
  187.                                  cout<<"Cola diesel: "; ver(diesel);cout<<endl;
  188.                                  simulacion(diesel);
  189.                                  cout<<endl;
  190.                                 }
  191.                                  break;
  192.                             case 3:
  193.                                 if(colaVacia(moto)== false){
  194.                                 cout<<"Cola motos: "; ver(moto); cout<<endl;
  195.                                 simulacion(moto);
  196.                                 cout<<endl;
  197.                                 }
  198.                                  break;
  199.                             case 4:
  200.                                 if(colaVacia(industrial)== false){
  201.                                 cout<<"Cola industrial: "; ver(industrial); cout<<endl;
  202.                                 simulacion(industrial);
  203.                                 cout<<endl;
  204.                                 }
  205.                                 break;
  206.                         }
  207.                 }
  208.                 break;
  209.                
  210.             case'F':
  211.                 return 0;
  212.                 break;
  213.                
  214.             default:
  215.                 cout<<"Elige una opcion correcta"<<endl;
  216.                
  217.            
  218.            
  219.         }
  220.     }while(i!='F');
  221.    
  222.  
  223.  
  224.  
  225.  
  226.     system("PAUSE");
  227.     return 0;
  228. }
  #3 (permalink)  
Antiguo 28/04/2016, 17:32
 
Fecha de Ingreso: octubre-2014
Ubicación: Madrid
Mensajes: 1.212
Antigüedad: 10 años, 1 mes
Puntos: 204
Respuesta: Duda con programa que gestiona ITV

Por lo que veo estás programando en C++. Has de saber entonces que

Código C++:
Ver original
  1. typedef struct vehiculo

lo puedes dejar en simplemente en

Código C++:
Ver original
  1. struct vehiculo

Que va a funcionar perfectamente. De hecho, el typedef sirve única y exclusivamente para definir alias y su uso es "typedef <tipo> <alias>" y el uso que tu le estás dando es "typedef <tipo>".

Esto en C se usaría así:

Código C:
Ver original
  1. typedef struct vehiculo
  2. {
  3. } vehiculo;

O así:

Código C:
Ver original
  1. struct vehiculo
  2. {
  3. };
  4. typedef struct vehiculo vehiculo;

Y la ventaja que obtienes con esta sintaxis (ojo, para el caso de struct y C) es que ya no es necesario usar struct para referirte a la variable.

Peeeero como hemos dicho, en C++ esto ya no es necesario, luego la siguiente declaración funciona igual de bien y es más limpia:

Código C++:
Ver original
  1. struct vehiculo
  2. {
  3.   vehiculo *sig;
  4. };

Aun así, no es por tocar mucho las narices pero yo esa clase la dividiría en dos: Por un lado los datos propios del vehículo y por otro la gestión de nodos:

Código C++:
Ver original
  1. struct vehiculo
  2. {
  3.   string matricula;
  4.   bool estado ;
  5.   char tipo;
  6.   string marca;
  7.   string modelo;
  8. };
  9.  
  10. struct nodo
  11. {
  12.   vehiculo datos;
  13.   nodo* sig;
  14. };

En programación conviene no mezclar churras con merinas para evitar errores. También estaría bien, dado que tienes tipos nativos (bool, char, un puntero...) implementar los constructores por defecto para evitar tener que hacer inicializaciones manuales so pena de dejar basura en las clases:

Código C++:
Ver original
  1. struct vehiculo
  2. {
  3.   string matricula;
  4.   bool estado ;
  5.   char tipo;
  6.   string marca;
  7.   string modelo;
  8.  
  9.   // opcion 1 para el constructor por defecto
  10.   vehiculo() : estado(false), tipo(' ')
  11.   {}
  12.  
  13.   // opcion 2: son equivalentes
  14.   vehiculo()
  15.   {
  16.     estado = false;
  17.     tipo = ' ';
  18.   }
  19. };
  20.  
  21. struct nodo
  22. {
  23.   vehiculo datos;
  24.   nodo* sig;
  25.  
  26.   nodo() : sig(0)
  27.   {}
  28. };

Otro consejo que te doy, pero depende también de si es requisito del ejercicio hacerlo así o no, es que en tu caso el tipo no debería ser un char sino un enumerado:

Código C++:
Ver original
  1. enum TipoVehiculo
  2. {
  3.   Ninguno,
  4.   Gasolina,
  5.   Diesel,
  6.   Moto,
  7.   Industrial
  8. };
  9.  
  10. struct vehiculo
  11. {
  12.   TipoVehiculo tipo;
  13. };

¿Por qué? En primer lugar porque así queda claro que esa variable no admite cualquier valor... ¿qué pasa si esperas encontrar una 'G' de gasolina y en alguna parte del programa se pone una 'g'? ¿Te dedicas a comprobar las dos combinaciones? ¿Y si te equivocas y pones una 'h' que está justo al lado del teclado? Con un enumerado no tienes esos problemas... de hecho si intentas hacer "tipo=gaoslina" el compilador te marcará un error en esa línea, ayudándote en la tarea de evitar errores en el código.

Si te preocupa la entrada de datos del usuario, para eso puedes usar bien una función:

Código C++:
Ver original
  1. TipoVehiculo ConvertirATipoVehiculo(char c)
  2. {
  3.   switch( c )
  4.   {
  5.     case 'G':
  6.       return Gasolina;
  7.     default:
  8.       return Ninguno;
  9.   }
  10. }

Seguimos:
Código C++:
Ver original
  1. typedef struct Cola
  2. {
  3.   struct vehiculo *cabecera;
  4.   struct vehiculo *ultimo;    
  5. }*lacola;

Dos cosas mal que veo en este código:
  • Si la lista es enlazada simple no tiene sentido alguno que tengas un puntero al último elemento de la lista.
  • Si creas un alias de un puntero por favor que el nombre indique esa característica de alguna forma.

Entre otras cosas puedes hacer que tu programa funcione sin hacer que "lacola" sea puntero. Para eso inventaron las referencias.

Yo la declaración de esa clase la dejaría así (asumiendo que haces también el cambio referente a separar la clase vehiculo):

Código C++:
Ver original
  1. struct Cola
  2. {
  3.   nodo*cabecera;
  4.  
  5.   Cola() : nodo(0)
  6.   {}
  7.  
  8.   // o si lo prefieres:
  9.  
  10.   Cola()
  11.   { nodo = 0; }
  12. };

Por otro lado no se si has visto o conoces de alguna manera los destructores y los métodos miembros de la clase, que te serían de gran utilidad. En este tema no me enrollo más porque entonces no me entraría todo en el mensaje, pero si quieres más detalles tu pregunta.

Bueno, el caso es que hemos dicho que no hace falta usar un puntero para "lacola" ¿Cómo es eso? Más o menos así:

Código C++:
Ver original
  1. // En C++ no hace falta poner void en la lista de parámetros
  2. Cola crearCola()
  3. {
  4.   Cola cola
  5.    
  6.   // No entiendo por qué la cola ha de tener de primeras un vehículo
  7.   // Lo suyo es que inicialmente estuviese vacía
  8.   // cola.cabecera = new struct vehiculo;
  9.  
  10.   // Esta línea estaba mal. Si la lista solo tiene un elemento por qué creas dos nodos?
  11.   // co->ultimo = new struct vehiculo;
  12.  
  13.   // y para colmo de males la reserva anterior la pierdes creando lagunas de memoria
  14.   // co->ultimo = NULL;
  15.  
  16.   // como las clases ahora tienen constructores, esto sobra
  17.   // co->cabecera->sig = NULL;
  18.  
  19.   return cola;
  20. }

Es decir, esta función no es necesaria:

Código C++:
Ver original
  1. int main()
  2. {
  3.   // Y ya está, ya son colas usables
  4.   Cola gasolina, diesel, moto, industrial;
  5. }

Otro ejemplo con referencias:

Código C++:
Ver original
  1. bool colaVacia(Cola& laco)
  2. {
  3.   // Las referencias usan el punto en vez de la flecha
  4.   return (laco.ultimo == NULL);
  5.  
  6.   // Si compilas con C++11 (estándar del 2011) también puedes dejarlo así
  7.   return (laco.ultimo == nullptr);
  8. }
  9.  
  10. // Las siguientes las puedes actualizar tu

Es de agradecer no usar memoria dinámica si podemos evitarlo porque su uso es complicado y es facil meter la pata y usar un puntero que no apunta a ningún sitio o dejarnos memoria sin liberar. Como por ejemplo...

Código C++:
Ver original
  1. void volver(lacola laco)
  2. {
  3.     struct vehiculo *nodo_aux;
  4.     nodo_aux = new struct vehiculo;
  5.     nodo_aux = laco->cabecera->sig; // <<--- AQUI!!!
  6.     laco->cabecera->sig = nodo_aux->sig;
  7.     laco->ultimo->sig = nodo_aux;
  8.     nodo_aux->sig = NULL;
  9.     laco->ultimo = nodo_aux;
  10. }

Fíjate que justo en la linea anterior has creado un objeto con new... si después asignas otro valor a ese puntero has perdido la memoria reservada con new. Ese new lo puedes eliminar con mucho cariño.

Te explico: Que uses un puntero no quiere decir que SIEMPRE tengas que hacer un new. Esto se hace únicamente cuando quieres crear un objeto nuevo. Si lo que pretendes es usar el puntero para acceder a elementos ya existentes no hay que usar new:

Código C++:
Ver original
  1. int* miClase1 = new int;
  2. int miClase2 = 2;
  3.  
  4. *miClase = 1;
  5.  
  6. int* ptr = miClase; // ptr y miClase apuntan al mismo elemento
  7. std::cout << *ptr << *miClase << std::endl; // imprime 11
  8.  
  9. *ptr = 10;
  10. std::cout << *ptr << *miClase << std::endl; // imprime 1010
  11.  
  12. // Ahora el puntero apunta a miClase2
  13. ptr = &miClase2;
  14. std::cout << *ptr << miClase2 << std::endl; // imprime 22
  15.  
  16. // Por cada new tenemos que poner un delete
  17. delete miClase;

Repasemos la implementación de la función quitar.

Código C++:
Ver original
  1. void quitar(lacola laco)
  2. {
  3.   // he quitado el código porque no me entraba el mensaje
  4. }

Vale, antes hemos visto que tener un puntero al último en una lista enlazada simple es un absurdo. Aquí vas a ver uno de las razones: Tener información redundante implica tener que actualizarla correctamente so pena de tener errores. Dicho en cristiano: "Si sabes que la lista termina cuando el "sig" de un nodo es 0... ¿Por qué te complicas usando cola->ultimo?

Aparte de eso tienes variables que no usas ni necesitas para nada:

Código C++:
Ver original
  1. void quitar(Cola& laco)
  2. {
  3.   if(colaVacia(laco))
  4.      cout << "LA COLA ESTA VACIA" << endl;
  5.   else
  6.   {
  7.     nodo* temp = laco.cabecera;
  8.     laco.cabecera = temp->cabecera;
  9.     delete temp;
  10.   }
  11. }

Y ya está, ya has quitado el primer elemento de la cola. Simplemente hay que hacer que cabecera apunte al segundo elemento y después borrar el nodo que queda huérfano. El sistema va a funcionar porque sabes que SIEMPRE se va a cumplir que el último nodo de la lista tiene su sig apuntando a 0 o NULL o nullptr, como prefieras.

Código C++:
Ver original
  1. void volver(lacola laco)
  2. {
  3.     struct vehiculo *nodo_aux;
  4.     nodo_aux = new struct vehiculo;
  5.     nodo_aux = laco->cabecera->sig;
  6.     laco->cabecera->sig = nodo_aux->sig;
  7.     laco->ultimo->sig = nodo_aux;
  8.     nodo_aux->sig = NULL;
  9.     laco->ultimo = nodo_aux;
  10. }

Otro cacao descomunal. Viendo un poco tu programa deduzco que esta función cola el primer nodo al final de la lista... veamos:

Código C++:
Ver original
  1. // estado inicial: A->B->C->D
  2.  
  3. // nodo_aux = B
  4. nodo_aux = laco->cabecera->sig;
  5.  
  6. // A->C->D
  7. laco->cabecera->sig = nodo_aux->sig;
  8.  
  9. // A->C->D->B
  10. laco->ultimo->sig = nodo_aux;

¿No es lo que esperabas, verdad?

Código C++:
Ver original
  1. void volver(Cola& laco)
  2. {
  3.   nodo* nodo = laco.cabecera;
  4.   // Si está vacía no podemos tocar nada.
  5.   // Si solo tiene un elemento tampoco porque el nodo es a la vez el primero y el último
  6.   if( nodo != 0 && nodo ->sig != 0)
  7.   {
  8.     // Ahora la lista empieza en el segundo nodo
  9.     laco.cabecera=nodo->sig;
  10.  
  11.     // Navegamos hasta el final de la lista
  12.     nodo* ptr = laco.cabecera;
  13.     while(ptr->sig)
  14.       ptr = ptr->sig;
  15.  
  16.     // ptr apunta al último nodo de la lista. Colocamos detrás el que era el primer nodo y actualizamos su sig.
  17.     ptr->sig = nodo;
  18.     nodo->sig = 0;
  19. }

Y bueno, recapitulando. Tus mayores problemas están en la gestión de la cola y el uso de punteros. En eso tienes que ponerte las pilas.

También sería interesante y recomendable que empezases a usar el depurador de código. Es una herramienta imprescindible para programar. Puede costar empezar a manejarla pero en seguida verás lo útil que resulta y pronto pasará a ser imprescindible para ti.

Un saludo.
__________________
La ayuda se paga con esfuerzo o con dinero. Si no estás dispuesto a esforzarte y quieres que te hagan los deberes pide presupuesto, al menos así ahorrarás tiempo.
  #4 (permalink)  
Antiguo 29/04/2016, 06:14
 
Fecha de Ingreso: abril-2016
Mensajes: 3
Antigüedad: 8 años, 6 meses
Puntos: 0
Respuesta: Duda con programa que gestiona ITV

Uff, no esperaba tener tanto que arreglar jaja. Aún estoy un poco verde pero me pondré las pilas. Gracias por contestar tan rápido, un saludo!
  #5 (permalink)  
Antiguo 30/04/2016, 02:43
 
Fecha de Ingreso: octubre-2014
Ubicación: Madrid
Mensajes: 1.212
Antigüedad: 10 años, 1 mes
Puntos: 204
Respuesta: Duda con programa que gestiona ITV

Aprender a programar no es algo trivial como intentan hacer ver con las campañas estás de enseñar a los niños a programar...

El único problema real de tu programa está en la forma de usar los punteros. El resto del mensaje lo uso para contarte buenas prácticas que te serán útiles en el futuro.

Programar C++ es especialmente difícil por lo extenso del lenguaje. Requiere algún que otro año empezar a dominar la mayor parte del lenguaje, así que paciencia y ánimo
__________________
La ayuda se paga con esfuerzo o con dinero. Si no estás dispuesto a esforzarte y quieres que te hagan los deberes pide presupuesto, al menos así ahorrarás tiempo.

Etiquetas: char, int, numero, programa, 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 09:41.