Problema con programa de pilas y colas. No puedo Compilar

[jom11]

Son tres errores al compilar: los Errores están en marcado con Rojo y con comentario al dlado con el error: me dice que no puede convertir a Void nose que estoy haciendo mal ¿?

Funciones para Pilas y Colas
a) Coloque los elementos de UNA pila en una COLA:
b) luego de los anterior. COPIE los elementos de la cola a un Vector




#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* El numero maximo de valores que se van a procesar es: */
#define MAX 10

/* El tipo de datos para cada nodo de la lista vinculada */
struct nodo {
int valor;
struct nodo *sig;
};
typedef struct nodo Nodo;

/* El tipo de datos para una pila */
struct pila {
Nodo *primero;
};
typedef struct pila *Pila;

/* El tipo de datos para una cola */
struct cola {
Nodo *primero;
Nodo *ultimo;
};
typedef struct cola *Cola;

/* Funciones para el manejo de una lista vinculada */
Nodo *Lista_Crear_Nodo(int valor);
Nodo *Lista_Insertar_Primero(Nodo *primero, int valor);
Nodo *Lista_Insertar_Ultimo(Nodo *ultimo, int valor);
int Lista_Sacar_Primero(Nodo **primero);
int Lista_Lista_Vacia(Nodo *primero);

/* Funciones para el manejo de una pila */
Pila Pila_Crear(void);
void Pila_Meter(Pila pila, int valor);
int Pila_Sacar(Pila pila);
void Pila_Listar(Pila pila);
int Pila_Esta_Vacia(Pila pila);
void Pila_Destruir(Pila pila);

/* Funciones para el manejo de una cola */
Cola Cola_Crear(void);
void Cola_Meter(Cola Cola, int valor);
int Cola_Sacar(Cola Cola);
void Cola_Listar(Cola Cola);
int Cola_Esta_Vacia(Cola Cola);
void Cola_Destruir(Cola Cola);

/*
** La funcion principal realiza la generacion de los valores, su
** almacenamiento en una pila y el paso de esta a una cola y de
** ahi a un vector.
*/
int main(void)
{
int vector[MAX];
int i;
int valor;

Pila pila;
Cola cola;

/*
** Definimos la semilla para los numeros aleatorios
** en base a la hora del sistema
*/
srand((unsigned) time(NULL));

/* 1) Generamos los valores y los almacenamos en una pila */
pila = Pila_Crear();

for (i = 0; i < MAX; i++){
valor = rand() % 100; /* Genera un valor entre 0 y 99 */
Pila_Meter(pila, valor);
}

printf("1) Valores en la pila:\n");
Pila_Listar(pila);
printf("\n");

/* 2) Pasamos todos los valores de la pila a la cola */
cola = Cola_Crear();

while (!Pila_Esta_Vacia(pila)){
valor = Pila_Sacar(pila);
Cola_Meter(cola, valor);
}

printf("2) Valores en la cola:\n");
Cola_Listar(cola);
printf("\n");

/* 3) Pasamos todos los valores de la cola al vector */
for (i = 0; i < MAX; i++){
vector[i] = Cola_Sacar(cola);
}

printf("3) Valores en el vector:\n");
for (i = 0; i < MAX; i++){
printf("vector[%d] == %d\n", i, vector[i]);
}
printf("\n");

/* 4) Liberamos la memoria destruyendo la pila y la cola */
Pila_Destruir(pila);
Cola_Destruir(cola);

return 0;
}

/* ---------------------------------------------------------------- */
/* 1) Funciones para el manejo de una lista vinculada */

/* Crea un nodo con el valor indicado, retorna su direccion en memoria */
Nodo *Lista_Crear_Nodo(int valor)
{
Nodo *nuevo;

nuevo = malloc(sizeof(Nodo)); /* ERROR: cannot convert 'Void *' to 'nodo * ' */
if (!nuevo){
printf("Error al crear un nodo!\n");
exit(1); /* 1 indica salida por algun error */
}

/* Valores iniciales del nodo */
nuevo->valor = valor;
nuevo->sig = NULL;

return nuevo;
}

/*
** Esta funcion crea un nodo con el valor indicado, el nodo
** se inserta como el primer nodo de la lista vinculada.
*/
Nodo *Lista_Insertar_Primero(Nodo *primero, int valor)
{
Nodo *nuevo;

nuevo = Lista_Crear_Nodo(valor);
nuevo->sig = primero;
primero = nuevo;

return nuevo;
}

/*
** Esta funcion crea un nodo con el valor indicado y se inserta como el
** ultimo nodo en la lista. Su valor de retorno es la direccion del ultimo
** nodo de la lista (el nodo recien creado).
*/
Nodo *Lista_Insertar_Ultimo(Nodo *ultimo, int valor)
{
Nodo *nuevo;

nuevo = Lista_Crear_Nodo(valor);
ultimo->sig = nuevo;

return nuevo;
}

/*
** Esta funcion saca el primer nodo de la lista, este nodo se destruye y
** su valor es el valor de retorno de la funcion.
*/
int Lista_Sacar_Primero(Nodo **primero)
{
Nodo *aux;
int valor;

/* Se toma nota del nodo a liberar y del valor a devolver por la funcion */
aux = *primero;
valor = aux->valor;

/* Actualizamos el puntero al primer nodo de la lista */
*primero = (*primero)->sig;
/* Liberamos la memoria utilizada por el nodo extraido de la lista */
free(aux);

return valor;
}

/* Esta funcion retorna Verdadero (o Falso) si la lista esta vacia (o no) */
int Lista_Lista_Vacia(Nodo *primero)
{
if (primero == NULL){
return 1;
}else {
return 0;
}
}

/* ---------------------------------------------------------------- */
/* 2) Funciones para el manejo de una pila */

/*
** Esta funcion reserva la memoria necesaria para una pila y retorna su
** direccion en memoria.
*/
Pila Pila_Crear(void)
{
Pila pila;

/* Reserva de memoria */
pila = malloc(sizeof(struct pila)); /* ERROR: cannot convert 'Void *' to 'pila * ' */
if (!pila){
printf("Error al reservar memoria para una pila!\n");
exit(1);
}

/* Valor inicial (es una pila vacia) */
pila->primero = NULL;

return pila;
}

/*
** Esta funcion mete el valor indicado en la pila colocandolo
** como el elemento en el tope de esta (primer nodo)
*/
void Pila_Meter(Pila pila, int valor)
{
pila->primero = Lista_Insertar_Primero(pila->primero, valor);
}

/* Esta funcion saca el valor del tope de la pila (primer nodo) */
int Pila_Sacar(Pila pila)
{
return Lista_Sacar_Primero(&(pila->primero));
}

/* Esta funcion lista los valores de la pila */
void Pila_Listar(Pila pila)
{
Pila aux;
int valor;

printf("(Tope)");

if (Pila_Esta_Vacia(pila)){
printf(" <Pila vacia>");
}else {
/* Para preservar el orden de la pila utilizamos una auxiliar */
aux = Pila_Crear();

/* Sacamos los valores de la pila para imprimirlos */
while (!Pila_Esta_Vacia(pila)){
valor = Pila_Sacar(pila);
printf(" %d", valor);

/* Los preservamos pasandolos a la pila auxiliar */
Pila_Meter(aux, valor);
}

/*
** Para restaurar la pila tomamos cada valor de la pila
** auxiliar y lo pasamos de nuevo a la pila original
*/
while(!Pila_Esta_Vacia(aux)){
valor = Pila_Sacar(aux);
Pila_Meter(pila, valor);
}

/* Como ultimo paso destruimos la pila auxiliar */
Pila_Destruir(aux);
}

printf(" (Fondo)\n");
}

/* Esta funcion retorna Verdadero (o Falso) si la pila esta vacia (o no) */
int Pila_Esta_Vacia(Pila pila)
{
return Lista_Lista_Vacia(pila->primero);
}

/* Esta funcion libera la memoria utilizada por la pila */
void Pila_Destruir(Pila pila)
{
/* Sacamos todos los valores de la pila, asi liberamos su memoria */
while (!Pila_Esta_Vacia(pila)){
Pila_Sacar(pila);
}

/* Liberamos la memoria de la pila */
free(pila);
}

/* ---------------------------------------------------------------- */
/* 3) Funciones para el manejo de una cola */

/* Esta funcion reserva memoria para una cola */
Cola Cola_Crear(void)
{
Cola cola;

/* Reserva de memoria */
cola = malloc(sizeof(struct cola)); /* ERROR: cannot convert 'Void *' to 'cola * ' */
if (!cola){
printf("Error al reservar memoria para una cola!\n");
exit(1);
}

/* Valores iniciales (es una cola vacia) */
cola->primero = NULL;
cola->ultimo = NULL;

return cola;
}

/*
** Esta funcion crea un nodo con el valor indicado y lo mete como
** el ultimo elemento de la cola
*/
void Cola_Meter(Cola cola, int valor)
{
if (Cola_Esta_Vacia(cola)){
cola->primero = Lista_Insertar_Primero(cola->primero, valor);
cola->ultimo = cola->primero;
}else {
cola->ultimo = Lista_Insertar_Ultimo(cola->ultimo, valor);
}
}

/* Esta funcion saca el valor al frente de la cola (primer nodo) */
int Cola_Sacar(Cola cola)
{
return Lista_Sacar_Primero(&(cola->primero));
}

/* Esta funcion lista los valores almacenados en la cola */
void Cola_Listar(Cola cola)
{
Cola aux;
int valor;

printf("(Primero)");

if (Cola_Esta_Vacia(cola)){
printf(" <Cola vacia>");
}else {
/* Para preservar la cola creamos una auxiliar */
aux = Cola_Crear();

/* Sacamos todos los elementos de la cola para imprimirlos */
while (!Cola_Esta_Vacia(cola)){
valor = Cola_Sacar(cola);

/* Cada valor se imprime y se guarda en la cola auxiliar */
printf(" %d", valor);
Cola_Meter(aux, valor);
}

/*
** Restauramos la cola original pasandole de nuevo todos
** los valores, estos se encuentran en la cola auxiliar
*/
while(!Cola_Esta_Vacia(aux)){
valor = Cola_Sacar(aux);
Cola_Meter(cola, valor);
}

/* Como ultimo paso destruimos la cola auxiliar */
Cola_Destruir(aux);
}

printf(" (Ultimo)\n");
}

/* Esta funcion retorna Verdadero (o Falso) si la cola esta vacia (o no) */
int Cola_Esta_Vacia(Cola Cola)
{
return Lista_Lista_Vacia(Cola->primero);
}

/* Esta funcion libera la memoria utilizada por la cola */
void Cola_Destruir(Cola Cola)
{
/* Vaciamos la cola para asi liberar la memoria de sus elementos */
while (!Cola_Esta_Vacia(Cola)){
Cola_Sacar(Cola);
}

/* Liberamos la memoria utilizada por la cola */
free(Cola);
}

[rir3760]

[jom11]

hola uso el turbo c ++ 3.0 , como hago para compilar solo en C y no en C++?

[rir3760]

Ese compilador no lo tengo instalado, lo mejor que te puedo recomendar es revisar su documentación (en Internet no encontraras mucha información sobre ese IDE debido a que fue desarrollado para MS-DOS).

Un saludo
_________________
C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language