ayuda con pilas

[maur1c10]

necesito hacer una programa con pilas en c++ acerca de un estacionamiento pero quiero que dentro de cada elemento de la pila de 5 elementos haya una estructura con los datos del auto para poder usar las funciones pop y push por ej.

funcion datos auto /* funcion para pedir datos del struct auto */
push(pila,struct auto)

tengo algo mas o menos asi pero quiero saber como usar pop y push con el struct

/* estructura vehiculo dentro de pila */
typedef char STACKELEMENT;
typedef struct {
int top;
STACKELEMENT items[STACKSIZE];
typedef struct vehiculo
{
char placa[7];
char cat[3];
char marca[15];
char nombre[50];
};
} STACK;


void intro()
{
char kat[3];
printf("\n digite el nombre del propietario:\n");
gets(vehiculo.nombre);
printf("\m digite el no. de placa del vehiculo (max. 6 digitos)\n:");
gets(vehiculo.placa);
printf("\n digite la marca del vehiculo:\n");
gets(vehiculo.marca);
printf("\n digite la categoria del vehiculo segun la letra mostrada:\n p-particular mb-microbus a-alquiler c-camion \n");
gets(kat);
if(kat=='p')
vehiculo.cat="particular";
else
if(kat=="mb")
vehiculo.cat="microbus";
else
if(kat=='a')
vehiculo.cat="alquiler";
else
if(kat=='c')
vehiculo.cat="camion";
else
printf("\n esa categoria no existe");
getch();
}

espero que puedan ayudarme

separe la estructura de la pila de la del vehiculo

typedef struct {
int top;
STACKELEMENT items[STACKSIZE];
} STACK;

typedef struct vehiculo
{
char placa[7];
char cat[3];
char marca[15];
char nombre[50];
};

me queda esto y quisiera poder hacer algo asi
suponiendo que STACKSIZE sea 5
push(pila,vehiculo) de manera que en cada elemento de la pila queden la estructura
de un vehiculo distinto

[margarito04]

las pilas son estruturas de datos cuyo comportamiento es FILO(por sus siglas en ingles que significa: primero en entrar ultimo en salir).

Normalmente en C++ o en C, las pilas son manejadas mediante una version simplificada de lo que es una lista enlazada y en particular en C++ se emplean clases. Aun que tu estrategia es igual de valida.

Para poder hacer lo quieres
Debes declar
1. una funcion que permita insertar al final de la lista.
a. tener un contador que permita saber en donde se encuentra el ultimo elemento insertado.
b. En tu caso como la pila solo va a tener 5 elemento validar que no se ha alcanzado este limite.

2. una funcion que permita extraer elementos de la pila. Consideraciones.
a. Mantener un apuntador siempre al inicio de la pila
b. validar que si no se a llegado al final de la pilal.

3. una funcion que permita validar si una pila esta vacia
la forma de saber en este caso que la pila esta vacia es verificar si el fin del la pila es igual al inicio de la pila

un pequeño ejemplo de como se podria del comportamiento de una pila.

pila; la pila al inicio debe estar vacia por lo que el contador el cual apunta al ultimo elemento siempre sera 0.

se inserta Auto1

finPila = 1
iniPila = 0
posicion En Pila 0
pila = [auto1]

se inserta Auto2
finPila = 2
iniPila = 0
posicion En Pila 0 1
pila = [Auto1|Auto2]

se inserta Auto3
finPila = 2
iniPila = 0
posicion En Pila 0 1 3
pila = [Auto1|Auto2|Auto3]

se saca un auto, debes tomar en cuenta que el sacar un elemento es logico, no fisico, esto es por ejemplo en tu arreglo van a permanecer los 3 autos, sin embargo para la pila solo van a existir los autos 2 y 3. Asi si el siguiente elemento que sacarias sería el 1, con cual iniPila = 2.

finPila = 3
iniPila = 1
posicion En Pila 0 1 2
pila = [ Auto1|Auto2|Auto3]

el autos que se obtiene es el Auto1

se inserta Auto4
finPila = 4
iniPila = 1
posicion En Pila 0 1 3 4
pila = [Auto1|Auto2|Auto3|Auto4]

se saca el un auto
finPila = 4
iniPila = 2
posicion En Pila 0 1 3 4
pila = [Auto1|Auto2|Auto3|Auto4]

El auto que se obtiene es el Auto2.

Cualquier duda, con gusto te contestare

[maur1c10]

gracias por responder las funciones pop, push, stackempty, ya las tengo hechas mi problema esta en que quiero meter en cada elemento de la pila un vehiculo por ej
pila[v1][v2][v3][v4][v5][v6][v7][v8][v9]

al principio mi programa pregunta si desea agregar un auto o retirarlo
cambie un poco el struct y le agregepara que fueran 9 estructuras tipo vehiculo creo que asi se hace

typedef char STACKELEMENT;
typedef struct {
int top;
STACKELEMENT items[STACKSIZE];
} STACK;

struct vehiculo{
char placa[7];
char cat[3];
char marca[15];
char nombre[50];
}v1,v2,v3,v4,v5,v6,v7,v8,v9;

donde lo que se me ocurre es hacer si la pila se llama p
push(p,v1) y llevar un contador para el no. de estructura de vehiculo
push(p,v[no])

[margarito04]

mas bien STACKELEMENT deberia ser de tipo vehiculo, asi

struct vehiculo{
char placa[7];
char cat[3];
char marca[15];
char nombre[50];
}v1,v2,v3,v4,v5,v6,v7,v8,v9;

typedef vehiculo STACKELEMENT;

typedef struct {
int top; //representa la parte final de tu cola = al numero de elementos
int botton; //agregar esta variable
STACKELEMENT items[STACKSIZE];
} STACK;

asi al momento de insertar Insertas en la posicion top e incrementas en uno top, y al sacar obtienes el valor en la posicion botton y lo incremas en uno. en un inicio los dos tendrian 0.

[maur1c10]

Iniciado por margarito04

mas bien STACKELEMENT deberia ser de tipo vehiculo, asi

struct vehiculo{
char placa[7];
char cat[3];
char marca[15];
char nombre[50];
}v1,v2,v3,v4,v5,v6,v7,v8,v9;

typedef vehiculo STACKELEMENT;

typedef struct {
int top; //representa la parte final de tu cola = al numero de elementos
int botton; //agregar esta variable
STACKELEMENT items[STACKSIZE];
} STACK;

asi al momento de insertar Insertas en la posicion top e incrementas en uno top, y al sacar obtienes el valor en la posicion botton y lo incremas en uno. en un inicio los dos tendrian 0.

margarito04 ahi pones algo de una cola pero en mi caso que es pila no afectaria?

bueno voy a poner a continuacion el codigo completo como lo tengo al compilar me da en la declaracion de la funcion push un error que dice ) expected y tambien en cada parte que uso push me dice cannot convert char to STACK o al reves

Código:

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>

#define TRUE 1
#define FALSE 0
#define STACKSIZE 100
#define num 9

/* definicion de tipos de datos */
typedef char STACKELEMENT;
typedef struct {
	int top;
	STACKELEMENT items[STACKSIZE];
        } STACK;

/* estructura de datos vehiculo */
struct vehiculo{
         char placa[7];
         char cat[14];
         char marca[15];
         char nombre[50];
        } vehiculo[num];


/*prototipos de funciones de la pila y funciones para el tipo vehiculo */
int introducir(STACK , int n);
int retirar(STACK , STACK , int n);
void verificar(STACK , int n);
void Clear(STACK *);
int Empty(STACK *);
int Full(STACK *);
STACKELEMENT Pop(STACK *);
void Push(STACK *, vehiculo);

/* funcion principal */
void main() {
 STACKELEMENT a;
 int p, i;
 STACK b;
 STACK *c=&b;
 STACK d;
 STACK *e=&d;
 d.top=-1;
 b.top=-1;
 clrscr();
 int op, n=0;

 printf("\n digite un numero segun la accion que desea realizar:\n1.Intruducir un vehiculo \n2.Retirar un vehiculo \n3.Verificar informacion de ultimo  vehiculo ingresado \n4.Salir \n");
 scanf("%i", &op);
 switch(op)
 {
   case 1:introducir(*c, n);
   break;
   case 2:retirar(*c, *e, n);
   break; 
   case 3:verificar(*c, n);
   break;
   case 4:exit(1);
   break;
 }
 getch();
}

 
/* funcion para introducir datos de vehiculo */
int introducir(STACK c, int n)
{
 char kat[3];
 printf("\n digite el nombre del propietario:\n");
 cin.getline (vehiculo[n].nombre,50);
 printf("\m digite el no. de placa del vehiculo (max. 6 digitos)\n:");
 cin.getline (vehiculo[n].placa,7);
 printf("\n digite la marca del vehiculo:\n");
 cin.getline (vehiculo[n].marca,15);;
 printf("\n digite la categoria del vehiculo segun la letra mostrada:\n p-particular mb-microbus a-alquiler c-camion \n");
 gets(kat);
 if(kat[0]=='p')
   strcpy(vehiculo[n].cat,"particular"); 
 else
  if((kat[0]=='m')&&(kat[1]=='b'))
    strcpy(vehiculo[n].cat,"microbus");
  else
    if(kat[0]=='a')
      strcpy(vehiculo[n].cat,"alquiler");
    else
      if(kat[0]=='c')
         strcpy(vehiculo[n].cat,"camion");
      else
       printf("\n esa categoria no existe");
 n++;
 Push(c, vehiculo[n]); 
 getch();
 return n;
}

/* funcion para retirar vehiculo usando la placa como identificador */ 
int retirar(STACK c, STACK e, int n)
{
 STACK p;
 STACK *p1=&p;
 p.top=-1;
 char plak[7]; 
 printf("\n digite el numero de placa del vehiculo que desea retirar:\n");
 gets(plak);
 if(vehiculo[n].placa==plak)
  e=Pop(&c);
 else
 { 
  while((vehiculo[n].placa!=plak)&&((&c)!=NULL))
   e=Pop(&c);
  if(vehiculo[n].placa==plak)
   {
    p1=Pop(&c);
    printf("\n vehiculo retirado exitosamente"); 
    n--;
    while((&e)!=NULL)
      c=Pop(&e);
   }  
   else
    while((&e)!=NULL)
      c=Pop(&e);
 } 
 getch();
 return n;
}

/* funcion para revisar informacion del ultimo vehiculo ingresado */
void verificar(STACK c,int n)
{
 if(Empty(&c))
  {
    printf("\n no hay vehiculos en el estacionamiento");
    exit(1);
  }
 printf("\n datos del ultimo vehiculo ingresado:");
 printf("\n\n nombre del propietario:\n");
 cout << vehiculo[n].nombre;
 printf("\n\n no. de placa del vehiculo:\n");
 cout << vehiculo[n].placa;
 printf("\n\n marca del vehiculo:\n");
 cout << vehiculo[n].marca;
 printf("\n\n categoria del vehiculo:\n");
 cout << vehiculo[n].cat;
} 
 

/* limpia la pila */
void Clear(STACK * ps) {
	ps->top= -1 ;
	}

/* verifica si la pila esta vacia */
int Empty(STACK * ps) {
	if (ps->top == -1)
		return(TRUE);
	else
		return(FALSE);
	}

/* verifica si la pila esta llena, si ya no se pueden introducir mas elementos en el arreglo */
int Full(STACK * ps) {
	if (ps->top == STACKSIZE - 1)
		return(TRUE);
	else
		return(FALSE);
	}

/* introduce un elemento en la pila */
void Push(STACK * ps, vehiculo x) {
     if (Full(ps)) {
		   printf("%s","Pila desbordada");
	 	   exit(1); }
     else
		   ps->items[++(ps->top)]=x;
   }
/* quita un elemento de la pila y lo devuelve */
STACKELEMENT Pop(STACK * ps) {
  if (Empty(ps)) {
		 printf("%s","Pila subdesbordada");
		 exit(1); }
  return(ps->items[(ps->top)--]);
 }

[margarito04]

puedes señalar en linea

[maur1c10]

bueno ahi pongo de nuevo el codigo con los errores en rojo y que error dice el programa turbo c++

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>

#define TRUE 1
#define FALSE 0
#define STACKSIZE 100
#define num 9

/* definicion de tipos de datos */
typedef char STACKELEMENT;
typedef struct {
int top;
STACKELEMENT items[STACKSIZE];
} STACK;

/* estructura de datos vehiculo */
struct vehiculo{
char placa[7];
char cat[14];
char marca[15];
char nombre[50];
} vehiculo[num];


/*prototipos de funciones de la pila y funciones para el tipo vehiculo */
int introducir(STACK , int n);
int retirar(STACK , STACK , int n);
void verificar(STACK , int n);
void Clear(STACK *);
int Empty(STACK *);
int Full(STACK *);
STACKELEMENT Pop(STACK *);
void Push(STACK *, vehiculo); // ) expected

/* funcion principal */
void main() {
STACKELEMENT a;
int p, i;
STACK b;
STACK *c=&b;
STACK d;
STACK *e=&d;
d.top=-1;
b.top=-1;
clrscr();
int op, n=0;

printf("\n digite un numero segun la accion que desea realizar:\n1.Intruducir un vehiculo \n2.Retirar un vehiculo \n3.Verificar informacion de ultimo vehiculo ingresado \n4.Salir \n");
scanf("%i", &op);
switch(op)
{
case 1:introducir(*c, n);
break;
case 2:retirar(*c, *e, n);
break;
case 3:verificar(*c, n);
break;
case 4:exit(1);
break;
}
getch();
}


/* funcion para introducir datos de vehiculo */
int introducir(STACK c, int n)
{
char kat[3];
printf("\n digite el nombre del propietario:\n");
cin.getline (vehiculo[n].nombre,50);
printf("\m digite el no. de placa del vehiculo (max. 6 digitos)\n:");
cin.getline (vehiculo[n].placa,7);
printf("\n digite la marca del vehiculo:\n");
cin.getline (vehiculo[n].marca,15);;
printf("\n digite la categoria del vehiculo segun la letra mostrada:\n p-particular mb-microbus a-alquiler c-camion \n");
gets(kat);
if(kat[0]=='p')
strcpy(vehiculo[n].cat,"particular");
else
if((kat[0]=='m')&&(kat[1]=='b'))
strcpy(vehiculo[n].cat,"microbus");
else
if(kat[0]=='a')
strcpy(vehiculo[n].cat,"alquiler");
else
if(kat[0]=='c')
strcpy(vehiculo[n].cat,"camion");
else
printf("\n esa categoria no existe");
n++;
Push(c, vehiculo[n]); // function Push should have a prototype
getch();
return n;
}

/* funcion para retirar vehiculo usando la placa como identificador */
int retirar(STACK c, STACK e, int n)
{
STACK p;
STACK *p1=&p;
p.top=-1;
char plak[7];
printf("\n digite el numero de placa del vehiculo que desea retirar:\n");
gets(plak);
if(vehiculo[n].placa==plak)
e=Pop(&c); // Cannot convert 'char' to 'STACK'
else
{
while((vehiculo[n].placa!=plak)&&((&c)!=NULL))
e=Pop(&c); // Cannot convert 'char' to 'STACK'
if(vehiculo[n].placa==plak)
{
p1=Pop(&c); // Cannot convert 'char' to 'STACK'
printf("\n vehiculo retirado exitosamente");
n--;
while((&e)!=NULL)
c=Pop(&e); // Cannot convert 'char' to 'STACK'
}
else
while((&e)!=NULL)
c=Pop(&e); // Cannot convert 'char' to 'STACK'
}
getch();
return n;
}

/* funcion para revisar informacion del ultimo vehiculo ingresado */
void verificar(STACK c,int n)
{
if(Empty(&c))
{
printf("\n no hay vehiculos en el estacionamiento");
exit(1);
}
printf("\n datos del ultimo vehiculo ingresado:");
printf("\n\n nombre del propietario:\n");
cout << vehiculo[n].nombre;
printf("\n\n no. de placa del vehiculo:\n");
cout << vehiculo[n].placa;
printf("\n\n marca del vehiculo:\n");
cout << vehiculo[n].marca;
printf("\n\n categoria del vehiculo:\n");
cout << vehiculo[n].cat;
}


/* limpia la pila */
void Clear(STACK * ps) {
ps->top= -1 ;
}

/* verifica si la pila esta vacia */
int Empty(STACK * ps) {
if (ps->top == -1)
return(TRUE);
else
return(FALSE);
}

/* verifica si la pila esta llena, si ya no se pueden introducir mas elementos en el arreglo */
int Full(STACK * ps) {
if (ps->top == STACKSIZE - 1)
return(TRUE);
else
return(FALSE);
}

/* introduce un elemento en la pila */
void Push(STACK * ps, vehiculo x) { // ) expected
if (Full(ps)) {
printf("%s","Pila desbordada");
exit(1); }
else
ps->items[++(ps->top)]=x;
}
/* quita un elemento de la pila y lo devuelve */
STACKELEMENT Pop(STACK * ps) {
if (Empty(ps)) {
printf("%s","Pila subdesbordada");
exit(1); }
return(ps->items[(ps->top)--]);
}