Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
ANSIC: Cabecera y Archivo Fuente Introducción: Últimamente he realizado aplicaciones pequeñas que pensé no necesitaba separar en módulos, lo curioso fue que estaba equivocado, tanto aplicaciones pequeñas como grandes requieren de la separación de módulos independientes para poder reutilizar el código entre otras ventajas que explicare más delante. Razón por la cual decidí realizar este post con el objetivo de aprender y espero sea de utilidad para otras personas. Para comenzar debemos aclarar que los lenguajes de programación actuales nos permiten el desarrollo de aplicaciones modulares, para permitir la reutilización de código y evitar rediseñar segmentos independientes que fueron creados en proyectos anteriores. Por esta razón los programadores pueden separar un programa en componentes más pequeños, en “C” se llaman módulos o subrutinas y en “C++” clases. Estos subprogramas permiten reutilizar y distribuir el código creado anteriormente. Las ventajas que ofrece al segmentar un programa son las siguientes:
Si un equipo está desarrollando el programa, cada integrante puede desarrollar un módulo y al final integrar todo el proyecto. Mejor organización, ya que puedes agrupar funciones relacionadas en un mismo modulo, estilo orientado a objetos. La reutilización de los módulos en proyectos nuevos, reduciendo el tiempo de desarrollo. Cuando se realiza un cambio en algún modulo solo ese modulo es recompilado nuevamente y no todo el programa.
Cabecera: Los archivos de cabecera (“header” en ingles) son archivos con extensión “*.h” y tienen el objetivo de declarar la interface del modulo y no el como esta implementado. En la interface solo se debe poner código que deseamos sea utilizado por otros módulos y no aquel código que sea de uso interno para el modulo. Los archivos de cabecera están formados por dos partes en general. 1. La primera parte es el protector de cabecera, el cual se utiliza para evitar que el mismo código de la cabecera se repita si esta misma cabecera es incluida en algún otro archivo fuente. Para poner el protector se utilizan el siguiente código del preprocesador: #ifndef NOMBRECABECERA_H #define NOMBRECABECERA_H // Interface o contenido de cabecera #endif
1
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
2. La segunda parte es la interface o contenido de cabecera que consiste en: Cabeceras adicionales: o #include <stdio.h> o #include “suma.h” Constantes, enumeraciones y redefiniciones de tipo: o const unsigned char total; o enum numeros {cero,uno,dos,tres,cuatro,cinco,seis,siete,ocho,nueve,diez} o typedef unsigned char u8; Definición de estructuras, uniones y arreglos. o struct Reloj { unsigned char Hora; unsigned char Minuto; unsigned char Segundo }; o unión { unsigned int Valor; struct { unsigned char LSB; unsigned char MSB } }; Instrucciones del preprocesador: o #define MAX_VOL 25 o #define, #ifdef, #ifndef, #undef, #if, #elif, #else, #endif, #error Declaraciones de funciones (prototipos): o unsigned char funcion1(unsigned char); o void funcion2(void); Comentarios sobre el uso de cada función. Consejos prácticos sobre la cabecera:
Incluir siempre protectores de cabecera. Incluir solamente las cabeceras adicionales que sean necesarias. Declarar constantes, definición de estructuras y uniones, no variables. Declarar las funciones (prototipos), no las definiciones. Cada cabecera debe tener una tarea en específica.
Archivo Fuente: El archivo fuente (“source file” en ingles) son archivos con extensión “*.c” y tienen el objetivo de definir todo lo declarado en la cabecera o interface del modulo, también define funciones o variables de uso interno (privadas). Se componen de:
Cabecera correspondiente al archivo fuente: o #include “cabecera” Variables externas, entre otras: o unsiged char Variable; Definición de las funciones: o unsigned char funcion1(unsigned char valor) { return valor * 2; }\
2
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Ejemplo 1: Suma (Nivel principiante) Para el primer ejemplo utilizaremos un programa muy básico que suma dos valores de 8 bits sin signo e imprime el resultado. Originalmente el programa principal y el modulo están contenidos en el mismo archivo:
main.c (original)
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
/* * Autor: * Fecha: * Sitio: * * Archivo: * Titulo: * Descripción: * Compilador: */
11.
#include <stdio.h> // printf();
12. 13.
// Definición o prototipo de suma() unsigned int suma(unsigned char, unsigned char);
14. 15. 16. 17. 18.
// Programa principal void main(){ // Variables de entrada y salida unsigned char a,b; unsigned int c;
Omar Gurrola 10/10/12 http://www.proprojects.wordpress.com main.c ANSIC: Cabecera y Archivo Fuente Ejemplo 1: Suma (Nivel principiante) Microchip C18 v3.4
19. 20. 21.
// Valores iniciales a = 255; b = 255;
22. 23.
// Realizamos la suma utilizando la función suma(); c = suma(a,b);
24. 25. 26.
// Imprimimos el resultado de la suma printf("El resultado de la suma es: %u\n"); }
27. 28. 29. 30.
// Definición de la función suma() unsigned int suma(unsigned char x, unsigned char y){ return (unsigned int)x + (unsigned int)y; }
3
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Para segmentar este programa lo primero que haremos es crear la cabecera e interface llamada “suma.h” utilizando la definición de suma(); (main.c-línea: 13), quedando de la siguiente manera:
suma.h
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
/* * Autor: * Fecha: * Sitio: * * Archivo: * Titulo: * Descripción: * Compilador: */
11. 12. 13. 14. 15. 16.
// Protector de cabecera #ifndef SUMA_H #define SUMA_H // Definición o prototipo de suma() unsigned int suma(unsigned char, unsigned char); #endif
Omar Gurrola 10/10/12 http://www.proprojects.wordpress.com suma.h ANSIC: Cabecera y Archivo Fuente Ejemplo 1: Suma (Nivel principiante) Microchip C18 v3.4
La declaración de suma(); (main.c-líneas: 28-30) se define en el archivo fuente llamado “suma.c” y se debe añadir la cabecera correspondiente al modulo (suma.c-línea 12) de la siguiente manera:
suma.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
/* * Autor: * Fecha: * Sitio: * * Archivo: * Titulo: * Descripción: * Compilador: */
Omar Gurrola 10/10/12 http://www.proprojects.wordpress.com suma.c ANSIC: Cabecera y Archivo Fuente Ejemplo 1: Suma (Nivel principiante) Microchip C18 v3.4
11. // Includes 12. #include "suma.h" 13. // Definición de la función suma() 14. unsigned int suma(unsigned char x, unsigned char y){ 15. return (unsigned int)x + (unsigned int)y; 16. }
4
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Para terminar, al programa principal le añadimos la cabecera del modulo “suma.h” (main.c-línea 12) y solamente utilizamos la función definido en ese modulo (línea: 22), quedando de la siguiente manera:
main.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
/* * Autor: * Fecha: * Sitio: * * Archivo: * Titulo: * Descripción: * Compilador: */
11. #include <stdio.h> 12. #include "suma.h"
Omar Gurrola 10/10/12 http://www.proprojects.wordpress.com main.c ANSIC: Cabecera y Archivo Fuente Ejemplo 1: Suma (Nivel principiante) Microchip C18 v3.4
// printf(); // suma();
13. // Programa principal 14. void main(){ 15. // Variables de entrada y salida 16. unsigned char a,b; 17. unsigned int c; 18. 19. 20.
// Valores iniciales a = 255; b = 255;
21. 22.
// Realizamos la suma utilizando la función suma(); c = suma(a,b);
23. 24. 25. }
// Imprimimos el resultado de la suma printf("El resultado de la suma es: %u\n");
5
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
El proceso para crear nuestra aplicación se realiza de la siguiente manera: 1. 2. 3.
Todas las cabeceras incluidas en cada archivos fuentes con añadidas al mismo. Cada archivo fuente es compilado y convertido en un archivo con extensión “*.o”. Por ultimo cada archivo objeto “*.o” y librerías utilizadas son ligados correctamente para obtener el programa final.
6
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Ejemplo 2: Pila LIFO (Nivel intermedio) Para este ejemplo implementaremos una pila LIFO (Last In First Out) en un modulo para que pueda ser reutilizada en cualquier proyecto futuro. La pila LIFO consiste en un arreglo donde podemos meter y sacar datos, con la característica de que el último dato en entrar es el primero en salir, esta pila es la mas sencilla de implementar. Lo primero es definir todo lo que se requiere para la interface:
El protector de cabecera (Líneas: 12,13 y 44). El tipo de datos que almacenara la pila (Línea: 17). El tipo de dato que regresara la pila si hubo un error (Línea: 18). El tipo de dato para alojar el índex de la pila (Línea: 19). El tamaño de la pila (Línea: 20). Constantes para regresar ERROR=0 y OK=1 (Línea: 21). Definición de función para meter un dato a la pila (Línea: 29). Definición de función para sacar un dato en la pila (Línea: 36). Definición de función para borrar toda la pila (Línea: 43). Comentarios de cada configuración y de los prototipos para su uso.
lifostack.h
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: lifostack.h * Description: LIFO Stack Header ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
#ifndef LIFOSTACK_H #define LIFOSTACK_H
14. 15.
/** INCLUDES *******************************************************/ //#include <>
16. 17. 18. 19. 20. 21.
/** INTERFACE CONFIGURATION ****************************************/ typedef unsigned char LIFOSTACK_TYPE; // Stack type typedef unsigned char LIFOSTACK_RESULT; // Result type (Just return 0 or 1) typedef unsigned char LIFOSTACK_INDEX_TYPE; // Enough bits to fit LIFOSTACK_SIZE #define LIFOSTACK_SIZE 20 // Stack size enum {LIFOSTACK_RETURN_FAIL=0,LIFOSTACK_RETURN_OK=1}; // Functions return
22. 23. 24. 25. 26. 27. 28. 29.
/** PROTOTYPES *****************************************************/ /******************************************************************* * Function: LIFOSTACK_RESULT lifostack_push(LIFOSTACK_TYPE); * Input: Value to be pushed in the stack * Output: Result: 1 = Value pushed, 0 = Push fail because stack is full * Description: Push a value of type LIFOSTACK_TYPE to stack *******************************************************************/ LIFOSTACK_RESULT lifostack_push(LIFOSTACK_TYPE);
7
Por: Omar Gurrola
http://www.proprojects.wordpress.com
30. 31. 32. 33. 34. 35. 36.
/******************************************************************* * Function: LIFOSTACK_RESULT lifostack_push(LIFOSTACK_TYPE *); * Input: Pointer of type LIFOSTACK_TYPE to store extracted value * Output: Result: 1 = Value extracted, 0 = Pop fail because stack is empty * Description: Pop a value of type LIFOSTACK_TYPE from stack *******************************************************************/ LIFOSTACK_RESULT lifostack_pop(LIFOSTACK_TYPE *);
37. 38. 39. 40. 41. 42. 43.
/******************************************************************* * Function: void lifostack_clear(void); * Input: None * Output: None * Description: Clear FIFO Stack *******************************************************************/ void lifostack_clear(void);
44.
#endif // LIFOSTACK_H
Versi贸n: v1.0 [10/10/12]
8
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Teniendo bien definida nuestra cabecera e interface podemos proceder a crear el archivo fuente en el cual vamos a realizar lo siguiente:
Incluir la cabecera del modulo (Línea: 13). Definir el arreglo privado que se utilizara de pila (Línea: 15). Definir el índex privado que se utilizara para administrar la pila y debe iniciar en cero (Línea: 16). La definición de la función para meter un dato (Líneas: 18-26). La definición de la función para sacar un dato (Líneas: 27-35). La definición de la función para borrar toda la pila (Líneas: 36-38). Todo el modulo debe estar comentado preferentemente.
lifostack.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: lifostack.c * Description: LIFO Stack Source File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
/** INCLUDES *******************************************************/ #include "lifostack.h"
14. 15. 16.
/** MODULE PRIVATE *************************************************/ LIFOSTACK_TYPE lfstack[LIFOSTACK_SIZE]; // Array for LIFO Stack LIFOSTACK_INDEX_TYPE index = 0; // index of stack
17. 18. 19. 20.
/** FUNCTION DEFINITIONS *******************************************/ LIFOSTACK_RESULT lifostack_push(LIFOSTACK_TYPE value){ if(index < LIFOSTACK_SIZE){ // Before push a value check if stack is full. lfstack[index++] = value; // Stack is not full, so push new value in stack and increment index after. return LIFOSTACK_RETURN_OK; // Return OK. } else{ // Stack is full. return LIFOSTACK_RETURN_FAIL; // Do nothing and return FAIL. } }
21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35.
LIFOSTACK_RESULT lifostack_pop(LIFOSTACK_TYPE *pvalue){ if(index > 0){ // Before pop a value check if stack is empty. *pvalue = lfstack[--index]; // Stack isn't empty, so pop a value and decrement index before. return LIFOSTACK_RETURN_OK; // Return OK. } else{ // Stack is empty. return LIFOSTACK_RETURN_FAIL; // Do nothing and return FAIL. } }
36. 37. 38.
void lifostack_clear(void){ index = 0; }
// To clear stack just put index to cero.
9
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Tendiendo todo el modulo listo procedemos a incluir la cabecera “lifostack.h” y el archivo fuente “lifostack.c” al proyecto y en “main.c” añadimos la cabecera “lifostack.h” para poder utilizar el modulo, probaremos el modulo de la siguiente manera:
Primero llenaremos toda la pila (Líneas: 17-24). Luego sacaremos todos los datos de la pila (Líneas: 26-33). Después llenaremos la pila e intentaremos meter cinco datos mas, los cuales no nos debe permitir (Líneas: 3542). Procedemos a vaciar la pila (Línea: 44) Por ultimo intentamos sacar cinco datos, los cuales no nos debe permitir (Líneas: 45-52).
main.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: main.c * Description: Example of LIFO Stack ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
#include <stdio.h> #include "lifostack.h"
14. 15.
void main(){ unsigned char x,z;
// printf(); // lifostack_push(); lifostack_pop();
16. 17. 18. 19. 20. 21. 22. 23. 24.
// First let’s push full stack for(x=0;x<LIFOSTACK_SIZE;x++){ if(lifostack_push(x)){ printf("Push Value: %u\n",x); } else{ printf("Stack is full!!\n"); } }
25. 26. 27. 28. 29. 30. 31. 32. 33.
// Next let’s pop full stack for(x=0;x<LIFOSTACK_SIZE;x++){ if(lifostack_pop(&z)){ printf("Pop Value: %u\n",z); } else{ printf("Stack is empty!!\n"); } }
34. 35. 36. 37. 38. 39. 40. 41. 42.
// Now let’s overfill stack with LIFOSTACK_SIZE + 5 for(x=0;x<LIFOSTACK_SIZE+5;x++){ if(lifostack_push(x)){ printf("Push Value: %u\n",x); } else{ printf("Stack is full!!\n"); } }
10
Por: Omar Gurrola 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53.
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
// Now let’s clear the stack and try to pop 5 values lifostack_clear(); for(x=0;x<5;x++){ if(lifostack_pop(&z)){ printf("Pop Value: %u\n",z); } else{ printf("Stack is empty!!\n"); } } }
11
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Ejemplo 3: Pila FIFO (Nivel intermedio) Para este ejemplo desarrollaremos el modulo de una pila FIFO (First In First Out), no entrare mucho en detalle ya que se diseña y segmenta de la misma forma que el ejemplo 3, con la única diferencia de que cambia el algoritmo para administrar la pila.
fifostack.h
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: fifostack.h * Description: FIFO Stack Header ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
#ifndef FIFOSTACK_H #define FIFOSTACK_H
14. 15.
/** INCLUDES *******************************************************/ //#include <>
16. 17. 18. 19. 20. 21.
/** INTERFACE CONFIGURATION ****************************************/ typedef unsigned char FIFOSTACK_TYPE; // Stack type typedef unsigned char FIFOSTACK_RESULT; // Result type (Just return 0 or 1) typedef unsigned char FIFOSTACK_INDEX_TYPE; // Enough bits to fit STACK_SIZE #define FIFOSTACK_SIZE 20 // Stack size enum {FIFOSTACK_RETURN_FAIL=0,FIFOSTACK_RETURN_OK=1}; // Functions return
22. 23. 24. 25. 26. 27. 28. 29.
/** PROTOTYPES *****************************************************/ /******************************************************************* * Function: FIFOSTACK_RESULT fifostack_push(FIFOSTACK_TYPE); * Input: Value to be pushed in the stack * Output: Result: 1 = Value pushed, 0 = Push fail because stack is full * Description: Push a value of type FIFOSTACK_TYPE to stack *******************************************************************/ FIFOSTACK_RESULT fifostack_push(FIFOSTACK_TYPE);
30. 31. 32. 33. 34. 35. 36.
/******************************************************************* * Function: FIFOSTACK_RESULT fifostack_push(FIFOSTACK_TYPE *); * Input: Pointer of type FIFOSTACK_TYPE to store extracted value * Output: Result: 1 = Value extracted, 0 = Pop fail because stack is empty * Description: Pop a value of type FIFOSTACK_TYPE from stack *******************************************************************/ FIFOSTACK_RESULT fifostack_pop(FIFOSTACK_TYPE *);
37. 38. 39. 40. 41. 42. 43.
/******************************************************************* * Function: void fifostack_clear(void); * Input: None * Output: None * Description: Clear FIFO Stack *******************************************************************/ void fifostack_clear(void);
44.
#endif // FIFOSTACK_H
12
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versi贸n: v1.0 [10/10/12]
fifostack.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: fifostack.c * Description: FIFO Stack Source File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
/** INCLUDES *******************************************************/ #include "fifostack.h"
14. 15. 16. 17. 18.
/** MODULE PRIVATE *************************************************/ FIFOSTACK_TYPE ffstack[FIFOSTACK_SIZE]; // Array for FIFO Stack FIFOSTACK_INDEX_TYPE counter = 0; // counter of stack FIFOSTACK_INDEX_TYPE in = 0; // in index FIFOSTACK_INDEX_TYPE out = 0; // out index
19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32.
/** FUNCTION DEFINITIONS *******************************************/ FIFOSTACK_RESULT fifostack_push(FIFOSTACK_TYPE value){ if(counter < FIFOSTACK_SIZE){ // Before push a value check if stack is full. ffstack[in++] = value; // Stack is not full, so push new value in stack. counter++; // One more element in the stack if(in == FIFOSTACK_SIZE){ // If in reach STACK_SIZE. in = 0; // Reset to cero. } return FIFOSTACK_RETURN_OK; // Return OK. } else{ // Stack is full. return FIFOSTACK_RETURN_FAIL; // Do nothing and return FAIL. } }
33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45.
FIFOSTACK_RESULT fifostack_pop(FIFOSTACK_TYPE *pvalue){ if(counter > 0){ *pvalue = ffstack[out++]; counter--; if(out == FIFOSTACK_SIZE){ out = 0; } return FIFOSTACK_RETURN_OK; } else{ return FIFOSTACK_RETURN_FAIL; } }
46. 47. 48. 49. 50.
void fifostack_clear(void){ counter = 0; in = 0; out = 0; }
// Before pop a value check if stack is empty. // Stack isn't empty, so pop a value. // If out reach STACK_SIZE. // Reset to cero. // Return OK. // Stack is empty. // Do nothing and return FAIL.
// counter to cero. // in to cero // out to cero
13
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
main.c
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.
/********************************************************************* * By: Omar Gurrola * Company: http://proprojects.wordpress.com * Processor: PIC18 * Compiler: C18 v3.4 * File Name: main.c * Description: Example of FIFO Stack ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Rev. Date Comment * 1.0 10/10/12 Initial version ********************************************************************/
12. 13.
#include <stdio.h> #include "fifostack.h"
14. 15.
void main(){ unsigned char x,z;
// printf(); // fifostack_push(); fifostack_pop(); fifostack_clear();
16. 17. 18. 19. 20. 21. 22. 23. 24.
// First let’s push full stack for(x=0;x<FIFOSTACK_SIZE;x++){ if(fifostack_push(x)){ printf("Push Value: %u\n",x); } else{ printf("Stack is full!!\n"); } }
25. 26. 27. 28. 29. 30. 31. 32. 33.
// Next let’s pop full stack for(x=0;x<FIFOSTACK_SIZE;x++){ if(fifostack_pop(&z)){ printf("Pop Value: %u\n",z); } else{ printf("Stack is empty!!\n"); } }
34. 35. 36. 37. 38. 39. 40. 41. 42.
// Now let’s overfill stack with FIFOSTACK_SIZE + 5 for(x=0;x<FIFOSTACK_SIZE+5;x++){ if(fifostack_push(x)){ printf("Push Value: %u\n",x); } else{ printf("Stack is full!!\n"); } }
43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53.
// Now let’s clear the stack and try to pop 5 values fifostack_clear(); for(x=0;x<5;x++){ if(fifostack_pop(&z)){ printf("Pop Value: %u\n",z); } else{ printf("Stack is empty!!\n"); } } }
14
Por: Omar Gurrola
http://www.proprojects.wordpress.com
Versión: v1.0 [10/10/12]
Referencias
Computación Gráfica FI, “Archivos de cabecera en C++”, 29/03/08, http://computaciongrafica.wordpress.com/2008/03/29/archivos-de-cabecera-en-c/.
Alex, “1.9 – Header files”, 03/06/07, http://www.learncpp.com/cpp-tutorial/19-header-files/.
Dave Marshall, “Writing Larger Programs”, 05/01/99, http://www.cs.cf.ac.uk/Dave/C/node35.html.
Brian W. Kernighan, Dennis M. Ritchie, “The C Programming Language”, Second Edition.
15