Antes de entrar por completo a programación orientada a objetos seria bueno recordar algo de “headers” y “structs”.

Es común usar estructuras para englobar ciertos datos en una sola variable, ya que seria un completo desastre almacenarlos en variables separadas, por lo que una estructura es la agrupación de variables.

Los Headers son archivos que se usan para agrupar la declaración de funciones, variables y tipos de datos, esto para poder administrarlos en un diferente lugar al programa principal, ya que al tener proyectos grandes nos da la posibilidad de ver una sobrevista de nuestras líneas de código.

Primero creamos un nuevo proyecto Foundation Tool, dentro de la carpeta Source creamos un archivo nuevo pero esta vez será uno de C File que se encuentra en C and C++, como nombre le podremos lifo, cada archivo de C que se crea viene acompañado de su archivo de cabecera, en este caso lifo.h, aquí solo declararemos la estructura a usar y la de nuestras funciones.

Por lo tanto nuestro archivo lifo.h va a tener la declaración de la estructura pila que la llamamos Lifo y de sus operaciones, quedando así:

  1. typedef struct {
  2.     int *pila;
  3.     int *topePila;
  4.     int currentIndex;
  5.     int maxValues;
  6. } LiFo;
  7.  
  8. void initLiFo(LiFo *pila, int numValues);
  9. void statusLiFo(LiFo *pila);
  10. void pushLiFo(LiFo *pila, int value);
  11. int popLiFo(LiFo *pila);

Ahora abriremos nuestro archivo lifo.c, aquí pondremos nuestras funciones que usaremos, estas representan las operaciones básicas de nuestra pila, nota: en C solo se pone la serie de funciones a usar, aquí tenemos que agregar la instrucción de #import "lifo.h"

  1. #import "lifo.h";
  2.  
  3. void initLiFo(LiFo *pila, int numValues){
  4.     pila->pila = calloc(numValues, sizeof(int));
  5.     pila->topePila = pila->pila;
  6.     pila->currentIndex = 0;
  7.     pila->maxValues = numValues;
  8. }
  9.  
  10. void statusLiFo(LiFo *pila){
  11.     int i=0;
  12.     printf("\nValores maximos: %i\n", pila->maxValues);
  13.     printf("Indice tope de pila: %i\n", pila->currentIndex);
  14.     printf("\t--------\n");
  15.     pila->pila--;
  16.     for (i=pila->currentIndex; i>0; i--){
  17.         printf("\t %i\n", *pila->pila);
  18.         pila->pila--;
  19.     }
  20.     pila->pila = pila->topePila;
  21. }
  22.  
  23. void pushLiFo(LiFo *pila, int value){
  24.     if (pila->currentIndex<pila->maxValues){
  25.         *pila->pila = value;
  26.         pila->pila++;
  27.         pila->topePila = pila->pila;
  28.         pila->currentIndex++;
  29.     }else{
  30.         printf("\n++ Desbordamiento de memoria ++\n");
  31.     }
  32. }
  33.  
  34. int popLiFo(LiFo *pila){
  35.     if (pila->currentIndex!=0){
  36.         pila->pila--;
  37.         int value = *pila->pila;
  38.         pila->topePila = pila->pila;
  39.         pila->currentIndex--;
  40.         return value;
  41.     }else{
  42.         printf("\n++ SubDesbordamiento de memoria ++\n");
  43.         return -1;
  44.     }
  45. }

Y por ultimo editaremos el archivo Pila.m, primero incluiremos el archivo lifo.h, ahora si podemos hacer uso de nuestra estructura y funciones, por lo que declaramos una pila de tipo Lifo, y hacemos las respectivas llamadas a funciones para manejar nuestra pila, un detalle es que pasamos nuestra pila por referencia a nuestra función, esto es que no enviamos los datos sino que enviamos la dirección de memoria de la pila:

  1. #import <Foundation/Foundation.h>
  2. #import <stdio.h>
  3. #import "lifo.h"
  4.  
  5. int main (int argc, const char * argv[]) {
  6.     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
  7.    
  8.     LiFo pila;
  9.     initLiFo(&pila,2);
  10.     printf("\nSe saco el elemento %i\n",popLiFo(&pila));
  11.     statusLiFo(&pila);
  12.     pushLiFo(&pila, 10);
  13.     pushLiFo(&pila, 12);
  14.     pushLiFo(&pila, 20);
  15.     statusLiFo(&pila);
  16.     printf("\nSe saco el elemento %i\n",popLiFo(&pila));
  17.     printf("\nSe saco el elemento %i\n",popLiFo(&pila));
  18.     pushLiFo(&pila, 13);
  19.     statusLiFo(&pila);
  20.    
  21.     [pool drain];
  22.     return 0;
  23. }

Listo ahora ya podemos dar un Build & Go, para ver el resultado de nuestro proyecto, por lo que podríamos ver algo así.