ESTRUCTURA DE UN PROGRAMA

EN C
Directivas del Preprocesador
Declaraciones globales
Tipo_devuelto main ()
{
Secuencia de Sentencias
}
Tipo_devuelto funcion_1 (lista de parámetros)
{
Secuencia de Sentencias
}
ESTRUCTURAS DE CONTROL
 Ejecución Secuencial: Ejecución de
instrucciones una a una en el orden que
están escritas.

 Transferencia de Control: Cuando se le

especifica al programa que la instrucción
a ejecutar no es la siguiente en la
secuencia de instrucciones.
ESTRUCTURAS DE CONTROL
 Estructuras Secuenciales
 Estructuras de Selección
○ Simple: if
○ Doble: if…else
○ Múltiple: switch case
 Estructuras de Repetición
○ While
○ Do…while
○ for
 ESTRUCTURAS DE CONTROL
 Operador Condicional Adicional
○ Operador Ternario(? :)->Requiere tres operandos.
 Primer Operando: Condición
 Segundo Operando: Valor si la condición es verdadera.
 Tercer Operando: Valor si la condición es falsa.

#include <stdio.h>

main(){
printf( (5>6)? "Mayor" : "Menor");

(5>6)? printf(" Mayor"): printf("Mayor");

}
ESTRUCTURAS DE RUPTURA DE
CONTROL
 Definición:
Estructuras que se utilizan para alterar un
flujo de control.

 Break: Permite:
○ Salir de un ciclo antes de su finalización.
○ Saltar el resto de una instrucción switch.
ESTRUCTURAS DE RUPTURA
 Continue:
○ Evita las instrucciones restantes del cuerpo
de una instrucción de control
(for,while,do..while) y ejecuta la iteración de
dicho ciclo.
○ En las sentencias while y do..while, se evalúa
la condición del ciclo después de la
instrucción continue
○ En la instrucción for el incremento se ejecuta
y posteriormente se evalúa la condición de
continuación del ciclo.
 TIPO DE DATO ENUMERADO
Conjunto entero de constantes
representadas mediante identificadores.

Sintaxis:
enum nombre_enum {lista_de_enumeración}
lista_de_variables;

Ejemplo:
enum MONEDAS{ peseta, duro, diez, cinco, cincuenta, cien,
doscientas, quinientas} monedas_espana;
 TIPO DE DATO ENUMERADO
Las enumeraciones asignan una constante entera a cada uno
de los símbolos de la enumeración, empezando por el valor 0.

Esto puede modificarse colocando en la declaración el valor

que deseamos tengan los elementos a partir de uno dado. Esto
se realiza de la siguiente forma:

enum CURSO{ primero, segundo, tercero, cuarto_t=100,

quinto_t, cuarto_e=200, quinto_e};
 MODOS DE ALMACENAMIENTO
 Static:
 Variables que al ser declaradas dentro de un bloque,
conservan su valor entre distintas ejecuciones de ese
bloque.
 Se declaran dentro de un bloque como las auto, pero
permanecen en memoria durante la ejecución de un
programa como las extern.
 La inicialización se realiza la primera vez. Por defecto se
inicializan n cero.
 Las funciones por defecto tienen modo extern.
 Una función puede definirse como static y sólo es visible
para las funciones que están definidas después de dicha
función y en el mismo fichero.
 MODOS DE ALMACENAMIENTO
 Ejemplo Static:

#include <stdio.h>
int turno()
{
static int contador = 0;
return contador ++;
}

int main()
{
int i;
for (i=0; i<10; i++)
printf("Turno: %d \n",turno());

return 0;
}
 MODOS DE ALMACENAMIENTO
 Register:
 Se utiliza para definir variables que se quieren accesar de
forma rápida.
 Dichas variables son almacenadas en los registros del
CPU y los cálculos sobre ella son más rápidos.
 Una variable register debe ser local a una función, nunca
puede ser global al programa completo.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Preprocesador: Editor de texto inteligente que consta de directivas.

 Directivas: Instrucciones que se dan al compilador antes de que se

compile el programa principal.

 Acciones del preprocesador:

 Inclusión de otros archivos en el archivo que se va a compilar.
 Definición de constantes simbólicas y macros.
 Compilación condicional de código del programa.
 Ejecución condicional de directivas del preprocesador.

 Todas las directivas del preprocesador empiezan con #.

 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #include
 Indica al compilador que lea el archivo fuente que se indica a
continuación de ella y que se incluya una copia del mismo en el
lugar de la directiva. Estos archivos se conocen como archivos
de cabecera (headers .h) o archivos de inclusión.

 Sintaxis
○ #include <nombrearchivo.h> Ejemplo: #include <stdio.h>
○ #include «nombrearchivo.h»
 Ejemplo: #include «prueba.h»
 Ejemplo: #include «C:\Programas\prueba.h»
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #define:
 Indica al compilador que defina un ítem de datos (constante
simbólica) u operación para el programa (macro).

 Sintaxis:
○ Constante simbólica:
 #define identificador texto-de-reemplazo
 Ejemplo: #define PI 3.14159

○ Macro:
 #define NombreMacro(parámetros_sin_tipos) expresión-de-
reemplazo
 Ejemplo: #define AREA_CIRCULO( x ) ( PI * ( x ) * ( x ) )
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #define: Constantes simbólicas
 Ejemplo: #define PI 3.14159

 Si la constante necesita modificarse en el programa, se modifica

una sola vez en la directiva del preprocesador #define y al
recompilar todas las ocurrencias de la constante en el programa
se modificarán.
 Todo lo que esta a la derecha del nombre de la constante
simbólica reemplaza a esta constante simbólica.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #define: macro
 Ejemplo: #define AREA_CIRCULO( x ) ( PI * ( x ) * ( x ) )

 Tipos:
 Sin argumentos: Se procesa como una constante simbólica.

 Con argumentos: Los argumentos se reemplazan en el texto-

de-reemplazo , y después la macro se expande (es decir, el
texto-de-reemplazo reemplaza el identificador de la macro y la
lista de argumentos en el programa).
 No hay comprobación de tipos de datos para los argumentos de
una macro. Esta se utiliza simplemente para sustituir el texto.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Ejemplo: area = AREA_CIRCULO( 4 );
 Se expande a area = ( 3.14159 * ( 4 ) * ( 4 ) );
 Como la expresión solo contiene constantes, en tiempo de
compilación el valor de la expresión se puede evaluar, y el
resultado se asigna a area en tiempo de ejecución.
 Los paréntesis alrededor de cada x en el texto de reemplazo y
alrededor de toda la expresión obligan a que se utilice el orden
de evaluación apropiado cuando el argumento de la macro es
una expresión.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Ejemplo: area = AREA_CIRCULO( c + 2 );
 Se expande a area = ( 3.14159 * ( c + 2 ) * ( c + 2 ) );
 La expresión se evalúa en forma correcta, ya que los paréntesis
obligan a que se utilice el orden de evaluación apropiado.

 Si se omiten los paréntesis, la expansión de la macro seria

area = 3.14159 * c + 2 * c + 2;

 La expresión se evalúa de forma incorrecta debido a las reglas

de precedencia de los operadores.
○ area = ( 3.14159 * c ) + ( 2 * c ) + 2;
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #ifndef, #endif: Compilación
condicional
 Compilación condicional: Permite controlar la ejecución de las
directivas del preprocesador y la compilación del código del
programa.
 Cada una de las directivas del preprocesador condicionales
evalúa una expresión entera constante que determinara si el
código se va a compilar o no.
 Las expresiones de conversión de tipos, las expresiones sizeof y
las constantes de enumeración no se pueden evaluar en las
directivas del preprocesador, ya que todas son determinadas por
el compilador y el preprocesamiento ocurre antes de la
compilación.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador #ifndef, #endif: Compilación
condicional
 Ejemplo:
//Determina si la constante simbólica NULL esta definida
#if !defined NULL
#define NULL 0
#endif
 Cada construcción #if termina con #endif.
 Las directivas #ifdef y #ifndef son abreviaciones de #if defined
(nombre) e #if !defined (nombre) respectivamente.
 Se puede evaluar una construcción del preprocesador
condicional que conste de varias partes mediante el uso de las
directivas #elif (equivalente de else if en una estructura if) y #else
(el equivalente de else en una estructura if).
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Ejemplo: Comentar porciones extensas de código
int main(){
#if 0
código que no se debe compilar
/*Imprime hola*/
#endif
printf("hola");
return 0;
}
 Para permitir que el código se compile se reemplaza el valor 0 en la
con el valor 1.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Ejemplo: Ayuda para la depuración.
#define DEPURAR 1
int main(){
int i;
int acum=0;
for(i=0;i<5;i++)
{
#ifdef DEPURAR
printf ("La variable i %d \n", i);
#endif
acum=acum+i;
}
printf("Acum: %d",acum);
return 0;
}
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Directiva del preprocesador Operador #
 Hace que un token del texto de reemplazo se convierta en una
cadena encerrada entre comillas.
 Ejemplo: #define HOLA( x ) printf("Hola, " #x " \n " ) ;

 Cuando aparece HOLA(Juan) en un archivo del programa, se

expande a printf("Hola, " " \n " ) ;
 La cadena "Juan" reemplaza a #x en el texto de reemplazo. Las
cadenas separadas por espacios en blanco se concatenan
durante el preprocesamiento, por lo que la instrucción anterior es
equivalente a printf("Hola, juan \n " ) ;
 Se debe utilizar el operador # en una macro con argumentos,
debido a que el operando de # hace referencia a un argumento
de la macro.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Las directivas del preprocesador : Operador ##
 El operador ## concatena dos tokens.
○ Ejemplo: #define CONCATTOKEN( x, y ) x ## y

 Los argumentos se concatenan y se utilizan para reemplazar la

macro.
○ Ejemplo, CONCATTOKEN( O, K ) se reemplaza por OK en el
programa. El operador ## debe tener dos operandos.
 COMANDOS DEL COMPILADOR Y
DIRECTIVAS DEL PREPROCESADOR
 Constantes simbólicas predefinidas
Constante Descripción
simbólica
__LINE__ El numero de línea de la línea actual de código fuente (una constante entera).
__FILE__ El presunto nombre del archivo de código fuente (una cadena).
__DATE__ La fecha de compilación del archivo de código fuente (una cadena de la forma
"Mmm dd aaaa", tal como "Ago 19 2002").
__TIME__ La hora de compilación del archivo de código fuente (una literal de cadena de la
forma "hh:mm:ss").

 Estos identificadores y el operador del preprocesador defined no

se pueden utilizar en directivas #define o #undef.
 Ejemplo:
○ printf("Fecha %s\n", __DATE__);
○ printf("Linea %d\n", __LINE__);
 OPERACIONES DE INCREMENTO Y
DECREMENTO
 Son operadores que suman o restan 1 a su argumento. (++ ó --).
 Pueden Utilizarse como Prefijo ó Sufijo dando resultados distintos.
 Si los operadores ++ ó – están como prefijo, la operación de
incremento o decremento se ejecutan antes de la operación de
asignación.
 Si los operadores ++ ó – están como sufijo, la operación de
incremento o decremento se ejecutan después de la operación de
asignación.
 OPERACIONES DE INCREMENTO Y
DECREMENTO
int m = 45, n = 75;
m=99,n;
printf("m=%d n=%d \n",m,n ); n=++m;
++m; printf("m=%d n=%d \n",m,n );
--n; n=m++;
printf("m=%d n=%d \n",m,n );
printf("m=%d n=%d \n",m,n ); printf("m=%d n=%d \n",++m,--n );
m++;
n--; printf("m=%d\n",m++);
printf("m=%d\n",++m);
printf("m=%d n=%d \n",m,n );
printf(" \n");
printf(" \n");
 OPERACIONES DE INCREMENTO Y
DECREMENTO
int m = 45, n = 75;
m=99,n;
printf("m=%d n=%d \n",m,n ); n=++m;
++m; printf("m=%d n=%d \n",m,n );
--n; n=m++;
printf("m=%d n=%d \n",m,n );
printf("m=%d n=%d \n",m,n ); printf("m=%d n=%d \n",++m,--n );
m++;
n--; printf("m=%d\n",m++);
printf("m=%d\n",++m);
printf("m=%d n=%d \n",m,n );
printf(" \n");
printf(" \n");
 CONVERSIÓN DE DATOS
 Definición: Convertir un valor de un tipo a otro sin cambiar el valor
que representa.

 C convierte valores cuando se asigna un valor de un tipo a una

variable de otro tipo.
 C convierte valores cuando se combinan tipos mixtos en
expresiones.
 C convierte valores cuando se pasan argumentos a funciones.
 CONVERSIÓN DE DATOS
 Implícita :
 Se ejecutan de forma automática.
 Se convierte un operador «angosto» en uno «amplio» sin pérdida
de información.
 Asignar un tipo mayor a uno más corto, o un tipo de punto
flotante a un entero no son ilegales, pero generan una
advertencia y resultados inesperados.
 CONVERSIÓN DE DATOS
#include <stdio.h>

#include <stdio.h> int main (){

int main (){ int i=12;
int var1='A';
printf("%c\n",var1); //A
double x=4;
printf("%d\n",var1); //65
printf("%c\n",var1 + 'a'); //ó x=x+i; /*i se convierte en double antes de la suma*/
printf("%c\n",var1 + 5); //F printf("%f\n",x);

x=i/5; /*primero se hace división entera, se convierte a double y luego se asigna a x*/
char var=65; printf("%f\n",x);
printf("%c\n",var); //A
printf("%d\n",var); //65
printf("%c\n",var + 'a'); //ó
x=4.0;
printf("%c\n",var + 5); //F } x=x/5; /*convierte 5 a double y luego hace división real y se asigna a x*/
printf("%f\n",x);
}
 CONVERSIÓN DE DATOS
 Explícita:
 Solicitadas específicamente por el programador.
 C realiza la conversión explícita a través del operador molde
(cast).

 Sintaxis
○ (tipo_nombre)valor;
 CONVERSIÓN DE DATOS
 Explícita:

 Ejemplo:
int ii=12;
printf("%f\n",(float)ii);

int precios = (int)11.99 + (int)11.99;

printf("%d\n",precios);

int precios1 = 11.99 + 11.99;

printf("%d\n",precios1);