Pilha - invertendo um vetor de inteiros II

O primeiro elemento que entra, é o último que sai,
Baseado no princípio LIFO ( Last IN, First OUT ),
ou o primeiro elemento inserido, será o último retirado.
é assim que funciona uma pilha que é o inverso de fila.
Os métodos principais de pilha são:
push() para inserir elementos na pilha.
top() para acessar elementos inserido na pillha.
pop() para retirar um elemento do topo.
empty() para verificar se a pilha está vazia ou não.
Para mostrar o funcionamento de uma pilha,
empilhamos 100 elementos inteiros num vetor,
e desempilhamos invertendo a ordem destes elementos.

Veja abaixo imagens do programa em execução:

Veja abaixo o código do programa:

#include <windows.h>

#include <stdio.h>

#include <conio.h>

/*============================================================================*/

//Criando uma moldura na tela do dos

int Moldura ( int tam_lin_ini, int tam_lin_fim, int tam_ini_col, int tam_fim_col ) {

     int i, c;

     for ( i = tam_lin_ini; i < tam_lin_fim; i++ ) {

         for ( c = tam_ini_col; c < tam_fim_col; c++ ) {

              gotoxy ( c, i );

              textbackground ( 0 );

              printf (" ");

         }

     }

     return 0;

}

/*============================================================================*/

typedef struct Pilha {

     int vol;

     struct Pilha *prox;

} Pil_ha;

Pil_ha cab;

Pil_ha *top;

bool x = false;

int Cria_Vetor ( int vet [ ], Pil_ha *to_po );

void Imprime_Pilha ( int vet [ ], Pil_ha *to_po );

/*============================================================================*/

void Informe ( ) {

     textcolor ( LIGHTBLUE );

     gotoxy ( 26, 20 );

     printf ( "Criado por: " );

     textcolor ( LIGHTMAGENTA );

     gotoxy ( 126, 20 );

     printf ( "Samuel Lima" );

     textcolor ( WHITE );

     gotoxy ( 23, 23 );

     printf ( "                                " );

     gotoxy ( 26, 21 );

     printf ( "sa_sp10@hotmail.com" );

     textcolor ( LIGHTRED );

     gotoxy ( 36 , 23 );

     printf ( "MUITO OBRIGADO" );

}

/*============================================================================*/

void Empi_lha ( int c , Pil_ha *to_po ) {

     Pilha *item = ( Pilha * ) malloc ( sizeof ( Pilha ) );

     item -> vol = c;

     item -> prox = to_po -> prox;

     to_po -> prox = item;

     x = true;

}

/*============================================================================*/

int Desem_pilha ( int vet [ ], Pil_ha *to_po ) {

     int c;

     Pil_ha *pt;

     pt = to_po -> prox;

     c = pt -> vol;

     to_po -> prox = pt -> prox;

     free ( pt );

     return c;

}

/*============================================================================*/

void Imprime_Pilha ( int vet [ ], Pil_ha *to_po ) {

     Cria_Vetor ( vet, top );

     int i;

     gotoxy ( 25, 7 );

     for ( i = 0; i < 100; i++ ) {

         if ( i == 10 ) {

              gotoxy ( 25, 8 );

         }

         if ( i == 20 ) {

              gotoxy ( 25, 9 );

         }

         if ( i == 30 ) {

              gotoxy ( 25, 10 );

         }

         if ( i == 40 ) {

              gotoxy ( 25, 11 );

         }

         if ( i == 50 ) {

              gotoxy ( 25, 12 );

         }

         if ( i == 60 ) {

              gotoxy ( 25, 13 );

         }

         if ( i == 70 ) {

              gotoxy ( 25, 14 );

         }

         if ( i == 80 ) {

              gotoxy ( 25, 15 );

         }

         if ( i == 90 ) {

              gotoxy ( 25, 16 );

         }

         if ( ( i < 10 ) && ( x == false ) ) {

              textcolor ( WHITE );

              printf ( "0" );

              Beep ( 1000, 200 );

         }

         //Para impressão da pilha empilhada

         if ( x == false ) {

              printf ( "%d ", vet [ i ] );

         }

         //Para impressão da pilha desimpilhada

         if ( x == true ) {

              textcolor ( WHITE );

              if ( (  i > 0 ) && ( i  >= 90 ) )

                   printf ( "0" );

              printf ( "%d " , Desem_pilha ( vet, top ) );

         }

     }//chave de fechamento do laço for

     textcolor ( LIGHTRED );

     gotoxy ( 29, 23 );

     printf ( "PRESSIONE QUALQUER TECLA" );

     getche ( );

}

/*============================================================================*/

int Cria_Vetor ( int vet [ ], Pil_ha *to_po ) {

     textcolor ( LIGHTRED );

     gotoxy ( 23 , 3 );

     printf ( "PILHA - INVERTENDO UM VETOR DE INTEIROS" );

     int i;

     for ( i = 0; i < 100; i++ ) {

         vet [ i ] = i;

     }

     return 0;

}

/*============================================================================*/

int main ( ) {

     //Colocando um título no "cmd"

     SetConsoleTitle ( "PILHA - INVERTENDO UM VETOR DE INTEIROS" );

     Moldura ( 2, 25, 2, 79 );

     int vet [ 100 ];

     int i;

     top = &cab;

     top -> prox = NULL;

     gotoxy ( 25 , 5 );

     printf ( "Impressão normal do vetor " );

     textcolor ( LIGHTGRAY );

     Imprime_Pilha ( vet, top );

     for ( i = 0; i < 100 ; i++ )

         Empi_lha ( vet [ i ], top );

     Moldura ( 2, 25, 2, 79 );

     textcolor ( LIGHTBLUE );

     gotoxy ( 25 , 5 );

     printf ( "Vetor invertido pela pilha" );

     Imprime_Pilha ( vet, top );

     Sleep ( 1800 );

     Informe ( );

     getche ( );

     exit ( 0 );

}

/*============================================================================*/