COMANDOS DEL PREPROCESADOR para dev ok

Vista previa del material en texto

C permite incluir en el programa fuente comandos destinados al compilador.
Son llevados a cabo antes del proceso de compilación. Son “pre-proceso”.
No son sentencias ejecutables.
No estarán presentes en el programa objeto ni el programa ejecutable.
Símbolo numeral (#)
Cuando el compilador inicia su tarea, busca en primer término estos comandos.
Para reconocerlos todos ellos comienzan con #.
Comandos del preprocesador
estándar ANSI
#define 	 #undef
#include		#if
#else		#elif
#endif		#error
#ifdef		#ifndef 
#line		#pragma
\
#define
Es una orden de reemplazo por la cual el compilador busca en el programa fuente una etiqueta y la sustituye por una cadena de caracteres todas las veces que esa etiqueta sea encontrada.
La etiqueta recibe el nombre de macro.
 
Usos de #define
Reemplazo de expresiones
Definición de constantes
Declaración de macros
Formato
#define etiqueta cadena de caracteres
Si la cadena no entra en una línea usar \
 #define nombre_de_macro cadena demasiado \
 				larga para ser ubicada en \
					una sola línea.
Ej: Reemplazo de etiqueta
#include <stdio.h>
#define TITULO "\nEste es el titulo"
int main ()
{
printf("\nTITULO\n");
printf (TITULO);
getchar();
}
Ej: Reemplazo de etiqueta
#include <stdio.h>
#define TITULO1 "\n ORGANIZACIÓN DE EMPRESAS"
#define TITULO2 "\n \n\t\t\t\t\t PRINCIPALES CLIENTES"
int main ()
{
printf("TITULO");
printf (TITULO1);
printf (TITULO2);
getchar();
}
Ej: Reemplazo incluyendo funciones
#include <stdio.h>
#define TITULO1 printf ("\n \n \t\t\t\t ORGANIZACIÓN DE EMPRESAS")
#define TITULO2 printf( "\n \n PRINCIPALES CLIENTES")
int main ()
{
printf("TITULO");
printf("\n \n");
TITULO1;
TITULO2;
getchar();
}
Definición de constantes
Una constante es un valor que permanece inalterado durante toda la ejecución del programa.
Para evitar modificar una constante, se puede usar el modificador const
Ej: const float PI = 3.1416;
PI no existe en memoria, sólo se guarda 3.1416 con ese nombre.
Si se le asigna otro valor da error
Ej: PI = 3.14;
#include <stdio.h>
int main ()
{
const float PI = 3.1416; 
printf("\n %f", PI);
PI=1.5;
//ESTO DA ERROR
printf("\n %f", PI);
getchar();
}
MACROS
	PROGRAMA
ASSEMBLER		MACRO PEPE		PROG. EN LEGUAJE DE MÁQUINA
					
					
					
					
	PEPE				
			REEMPLAZO		
					
					
					
	PEPE				
			REEMPLAZO		
					
					
FUNCIONES
	PROGRAMA EN LENGUAJE DE 
	MÁQUINA	FUNCIÓN PEPE
			
			
			
			
	PEPE		
			TRANSFERENCIA DE MAIN
			CONTROL Y RETURN A MAIN
			
			
	PEPE		
			USO DE LA PILA (LIFO) PARA
			IR A LA FUNCIÓN Y VOLVER
			AL MAIN
MACROS CON PARÁMETROS
#include <stdio.h>
#define imprimir(X) printf ("\nEl valor es %d", X)
//Esta macro sirve para imprimir “alguna cosa”
int main ()
{int A=2, B=4;
imprimir(A);
imprimir(B);
imprimir (5);
imprimir (A+B-3);
getchar();
}
MACRO DEFECTUOSA
#include <stdio.h>
#define cuad(X) X * X
int main ()
{int Z= 1;
// ESTA MACRO ES ERRONEA PORQUE FALTAN PARENTESIS EN LA DEFINICION
printf("\n %d ", cuad (2));
printf("\n %d ", cuad (Z));
printf("\n RESULTADO ERRONEO %d ", cuad (Z + 3));
getchar();
}
MACRO CORRECTA
#include <stdio.h>
#define cuad(X) (X) * (X)
int main ()
{int Z= 1;
printf("\n %d ", cuad (2));
printf("\n RESULTADO CORRECTO %d ", cuad (Z + 3));
getchar();
}
16
MACRO DEFECTUOSA II
#define lineal (M, X, N) (M) * (X) + (N)
void main ()
{int A= 2, Z= 3, B = 5;
printf(“\n %d ”, lineal (A, Z, B);
printf(“\n %d ”, 2*lineal (A, Z, B); // ACA DA RESULTADO ERRÓNEO
}
CORRECTA DEFINICIÓN DE LA MACRO:
#define lineal (M, X, N) ( (M) * (X) + (N))
MACRO CORRECTA II
#include <stdio.h>
#define lineal(M, X, N) ((M) * (X) + (N))
int main ()
{int A= 2, Z= 3, B = 5;
printf("\n %d ", lineal (A, Z, B));
printf("\n %d ", 2*lineal (A, Z, B)); 
//CORRECTA DEFINICIÓN DE LA MACRO
getchar();
}
EJ 6.MACRO CON OPERADOR “?”
#include <stdio.h>
#define MIN(A,B) (( (A) ) < ( (B ) ) ? ( A ) : ( B ))
int main ()
{
int X, Y ;
printf("\n Ingrese un par de valores enteros \n \n ");
scanf ("%d",&X) ;
scanf ( "%d",&Y) ;
printf("\n Datos %d %d", X, Y);
getchar();
printf ("\n \n El valor mínimo es %d" , MIN( X,Y) );
getchar();
}
EJ 7. MACRO DE IMPRESIÓN DE UN VECTOR
/*MACRO QUE IMPRIME UN VECTOR*/
#include <stdio.h>
#define MAX 10
#define impri(V,lon) { int I; for (I=0; I< lon; I++)\
 	 printf("\n \t %d", V[I]) ;}
int main ()
{
int VEC [MAX] , I ;
for ( I = 0 ; I < MAX ; I ++)
	VEC [I] = I;
impri(VEC , MAX);
getchar ();
}
EJ 8. ORDENAMIENTO DE UN VECTOR USANDO MACROS
/*3 MACROS QUE LEE, ORDENA Y MUESTRA UN VECTOR*/
#include <stdio.h>
#define MAX 10
#define imprimir(V , lon) { int I; for (I=0; I< lon; I++)\
 	 printf("\n \t %d", V[I]) ; getchar(); }
#define leer( V, lon) { int I; for (I=0; I<lon; I++) { \
 printf( "\n Ingrese el elemento %d =", I); \
 scanf ("%d", &V[I]); } }
 
 #define ordenar(V, lon) { int I, J, AUX; \
 for (I=0; I<lon-1;I++) \
 			 for (J=0; J<lon-I-1; J++) \
 			 if ( V[J] > V[J+1]) { \
 		 AUX = V[J]; \
 		 V[J] = V[J+1]; \
 			 V[J+1]= AUX; } }
 
int main ()
{int VEC [MAX] , I ;
leer (VEC , MAX);
ordenar(VEC, MAX);
imprimir (VEC , MAX);
getchar ();
}
#undef
Sirve para “desdefinir” macros
/* USO DE #undef*/
#include <stdio.h>
int main()
{
#define MACRO 20
printf ( " \n \t \t %d " , MACRO);
#undef MACRO
printf ( " \n \t \t %d " , MACRO); /* ERROR */
getchar();
}
#include
Hace que el compilador agregue al programa, otro archivo fuente y lo compile.
Los archivos se encuentran en \TC\INCLUDES y tienen extensión .h (headers, cabecera). Pueden tener otras extensiones.
Ejemplos:
#include <stdio.h>		Busca en \TC\INCLUDES
#include “vectores.mcr”.	 Busca en directorio actual
#include “F:\HEADERS\head1.txt” Busca en F:\HEADERS
BIBLIOTECAS DE FUNCIONES FUENTE
Se pueden construir archivos de texto compuestos por el cuerpo de funciones listas para ser compiladas. Incluso se pueden compilar en forma aislada , para que no generen errores.
EJ. 10. CABECERA PROPIA
Se creó el archivo FUNCION1.H con una función para imprimir vectores enteros.
/*FUNCION1.H*/
#include <STDIO.H>
void imprimir (int V [], int L)
{
 int I;
 for (I=0; I<L; I++)
 	printf("\n \t %d", V[I]);
}
PROGRAMA INCLUDE1.C incluye a FUNCION1.H
/* PROGRAMA INCLUDE1.C QUE INCLUYE LA FUNCION FUNCION1.H*/
#include <stdio.h >
#define MAX 10
#include "FUNCION1.H"
int main ()
{
	int VEC [MAX], I;
	for (I=0; I< MAX; I++)
		VEC[I] = I;
	imprimir (VEC, MAX);
	getchar();
}
CABECERA PROPIA CON FUNCIONES MÚLTIPLES. FUNCION2.H
/*FUNCION2.H*/
void imprimir (int V[], int L)
{ int I;
 for (I=0; I<L; I++)
 printf( "\n\t %d", V[I]); }
 
 void leer (int V[], int L)
 { int I;
 for (I=0; I<L; I++){
 printf( "\n Ingrese el elemento %d =", I);
 scanf ("%d", &V[I]); } 
 }
 void ordenar (int V[], int L)
 { int I, J, AUX;
 for (I=0; I<L-1;I++)
 for (J=0; J<L-I-1; J++)
 if (V[J]> V[J+1]){
 AUX = V[J];
 V[J] = V[J+1];
 V[J+1]= AUX;
 }
 } 
 
PROGRAMA INCLUDE2.C incluye a FUNCION2.H
/* PROGRAMA INCLUDE2.C QUE INCLUYE LA FUNCION FUNCION2.H*/
#include <stdio.h >
#define MAX 10
#include "FUNCION2.H"
int main ()
{
	int VEC [MAX], I;
	
	for (I=0; I< MAX; I++)
		VEC[I] = I;
	imprimir (VEC, MAX);
	getchar();
}
COMPARACION DE AMBOS PROGRAMAS
Se observan los tamaños de cada uno
INCLUDE1	 	243 bytes
INCLUDE2			244 bytes
INCLUDE1.EXE		15.960 bytes
INCLUDE2.EXE		16.710 byte
BIBLIOTECAS DE MACROS
Al igual que para las funciones, se pueden crear cabeceras que contienen macros.
EJ 12: MACRO1.H imprime un vector
/*MACRO1.H*/
#define imprimir (V,L) {int I; for (I=0; I< L; I++)\
 					printf("\n \t %d", V[I]);}
INCLUDE3 utiliza MACRO1.H
/* PROGRAMA INCLUDE3.C QUE INCLUYE LA FUNCION MACRO1.H*/
#include <stdio.h >
#include "MACRO1.H"
int main ()
{
	int V[10], I, L=10;
	for (I=0; I< L; I++)
		{V[I] = I;}
	imprimir(V, L);
	getchar();
}
BIBLIOTECA PROPIA DE MACROS
Se creó el archivo MACRO2.H con 3 macros
BIBLIOTECA PROPIA DE MACROS
MACRO2.H contiene 3 macros
/*MACRO2.H*/
#define imprimir(V,L) { int I; \
 for (I=0; I< L; I++)\
 	 printf("\n \t %d", V[I]) ;\
 getchar();}
#define leer(V,L) { int I; \
 for (I=0; I< L; I++) {\
 printf( "\n Ingrese el elemento %d =", I);\
 scanf ("%d", &V[I]);}}
 
 
 
#define ordenar(V , L) { int I, J, AUX; \
 for (I=0; I<L-1;I++) \
 			 for (J=0; J<L-I-1; J++) \
 			 if ( V[J] < V[J+1]) { \
 		 AUX = V[J]; \
 		 V[J] = V[J+1]; \
 			 V[J+1]= AUX; } }
 
INCLUDE4.C utiliza MACRO2.H
/* PROGRAMA INCLUDE4.C QUE INCLUYE LA FUNCION MACRO2.H*/
#include <stdio.h >
#include <conio.h >
#define MAX 10
#include "MACRO2.H"
int main ()
{
	int VEC [MAX], I;
	//clrscr();
	for (I=0; I< MAX; I++)
		VEC[I] = I;
	imprimir (VEC, MAX);
	getche();
}
Compilación Condicional
Las herramientas de compilación condicional permiten definir uno o más bloques del programa fuente que se compilarán (o no) según el cumplimiento (o no) de una condición, que es evaluado ANTES del proceso de compilación y por lo tanto NO PUEDE INCLUIR VARIABLES.
Sólo puede contener constantes previamente definidas, o por la definición o no de una macro.
Comandos de compilación condicional
#if #else funcionan como if … else de C
#elif se usa para escalonar
#endif delimita el bloque condicional
#ifdef verifica si la macro fue definida
#ifndef verifica si la macro no fue definida
ERROR
/* COMPILACION CONDICIONAL. ERROR. NO SE DECLARARON CONSTANTES*/
#include <stdio.h >
int main ()
{
	int A;
	
	A= 1000;
#if 500 < A
 printf ("VALOR GRANDE");
#endif	 	
	getchar();
}
SELECCIÓN ENTRE DOS BLOQUES
/* COMPILACION CONDICIONAL. SELECCION ENTRE DOS BLOQUES DE COMPILACION*/
#include <stdio.h >
#define MAX 2500
int main ()
{
	int VEC [MAX];	
	
#if 1000 < MAX
 printf ("CANTIDAD GRANDE DE ELEMENTOS");
 #else 
 printf ("CANTIDAD NORMAL DE ELEMENTOS");
 
#endif	 	
	
}
SELECCIÓN ENTRE MULTIPLES BLOQUES
En un proyecto real cada bloque puede ser largo y complejo.
Este recurso permite compilar sólo la parte del programa necesaria.
Se realiza la selección del bloque correspondiente a un país, ANTES de compilarlo y así se compila sólo la parte correspondiente al país seleccionado.
Selección entre múltiples bloques #elif 
/* COMPILACION CONDICIONAL. SELECCION ENTRE MULTIPLES BLOQUES DE COMPILACION*/
#include <stdio.h >
#define ARGENTINA 1
#define URUGUAY 2
#define BRASIL 3
#define PAIS BRASIL
int main ()
{
		
#if PAIS == ARGENTINA
 printf ("EL PAIS SELECCIONADO ES ARGENTINA ");
#elif PAIS == URUGUAY
	printf ("EL PAIS SELECCIONADO ES URUGUAY ");
#elif PAIS == BRASIL
	printf ("EL PAIS SELECCIONADO ES BRASIL"); 
#else 
 printf ("NO SE SELECCIONO NINGUN PAIS VALIDO");
 
#endif	 	
}
COMPILACION CONDICIONAL CON FINES DE DEPURACIÓN
Comando #ifdef 
El siguiente programa selecciona los bloques evaluando si la macro DEPURANDO esta definida o no.
Una vez que el programa ha sido analizado se puede eliminar la línea #define DEPURANDO o desdefinirla con #undef DEPURANDO y compilar nuevamente.
/* COMPILACION CONDICIONAL CON FINES DE DEPURACIÓN*/
#include <stdio.h >
/* DEJANDO O ELIMINANDO ESTA LÍNEA SE SELECCIONARÁ SI SE DESEA TENER IMPRESIONES DE SEGUIMIENTO O NO*/
#define DEPURANDO
int main ()
{
	int I, N, SUM = 0;		
#ifdef DEPURANDO
 int AUX = 0;
#endif	
	printf( "\n Ingrese un valor para calculo de la sumatoria \n", I); 
 scanf ("%d", &N); 
	for (I=0; I< N; I++){
		SUM += I;	
#ifdef DEPURANDO
	printf( "\n %d ", SUM);	
	AUX++;			
#endif		
		}	
	printf( "\n La sumatoria de todos los valores naturales");
	printf( "menores que %d vale %d ",N, SUM);
	
#ifdef DEPURANDO
	printf( "\n Calculado en %d vueltas, ", AUX);		
#endif	
}