Programación estructurada

M.T. María Luisa Juárez Aguilar, Lic.

Enero-junio 2020
 Temario    
•  Primer  parcial  20%:  
–  Fundamentos  de  lenguaje  C,    
–  Tipos  de  Datos  y  Operadores.    
–  Funciones  de  Entrada-­‐Salida.    
–  Estructuras  de  Selección  if,  switch    
•  Segundo  parcial  20%:  
–  Estructuras  repeFFvas  
–  Arreglos    
–   Structs    
•  Tercer  parcial  20%:  
–  Funciones    
–  Punteros    
–  Entrada  y  salida  con  archivos.  
Semana   Temas  

Historia, tipos de datos, expresiones, evaluación,

Semana 1  
estructura de un programa  
Entrada/salida estándar, programas básicos
Semana 2  
(Secuenciales)  

Semana 3   If simple, if/else  

Semana 4   If’s anidados, switch  

Semana 5   Ciclo for  

Semana 6   Ciclos while y do/while  

Semana 7   Arreglos en una dimensión (Vectores)  

Semana 8   Arreglos en dos dimensiones (Matrices)  

Semana 9   Cadenas y arreglos de cadenas  

Semana 10   Estructuras  

Semana 11   Funciones  

Semana 12   Funciones  

Semana 13   Apuntadores  

Semana 14   Apuntadores  

Semana 15   Archivos  
Textos  recomendados  
 Tema: Fundamentos del Lenguaje C/C++

•  Introducción al lenguaje C
Historia
Biblioteca estándar de C
Programación estructurada
•  Estructura básica de un programa en C
 Historia
•  Dennis Ritchie inventó y escribió el primer
compilador de C. —
•  Lenguajes antecesores de C: ALGOL 60,
CPL, BCPL, B.
•  C está basado en el concepto de
funciones.
•  Lenguaje de nivel medio, ya que combina
elementos de lenguajes de alto nivel con
la funcionalidad del ensamblador.
 Historia
•  Originalmente era utilizado para la
programación de sistemas operativos (UNIX),
intérpretes, editores, gestores de bases de
datos, etc.
•  Actualmente, los paquetes más populares se
realizan en C: Windows, Office y el mismo C.
•  Productos que utilizan una interfaz con C:
Oracle, Visual Basic, programación de
sockets para comunicación de datos entre
diversas plataformas (AS400 hasta UNIX).
 
 Historia
•  Sus herederos: C++, Java, C#, etc.
•  Prácticamente todo el software profesional
del mercado está escrito en algún dialecto
de C o proporciona una interfaz con C.
 Capítulo  3.  

EL  LENGUAJE  C:    
ELEMENTOS  BASICOS    
Luis  Joyanes  Aguilar  
Entorno de C/C++

Disco  
Editor  

Disco  
Preprocesador  

Disco  
Compilador  

Disco  
Editor  de  enlaces  
 Entorno de C/C++
Memoria principal
Cargador  
Pone el programa
ejecutable en memoria
Disco  

Memoria principal

La CPU ejecuta las

CPU  
instrucciones en la
memoria
 Primer ejemplo
#include <stdio.h> /*Librería para entrada y salida estandar*/

#include <conio.h> /*Librería para manejo de consola*/

int main() /*función principal*/

{
printf(”Curso de programación C \n”); /*función
de salida estandar*/
getch(); /*función de entrada de un carácter*/
return 0; /*sentencia return para terminar la
función principal*/
}
  
3.4.  DEPURACIÓN  DE  UN  PROGRAMA  EN  C    
 
•  Rara  vez  los  programas  funcionan  bien  la  primera  vez  que  
se  ejecutan.  Los  errores  que  se  producen  en  los  programas  
han  de  ser  detectados,  aislados  (fijados)  y  corregidos.  
•   El  proceso  de  encontrar  errores  se  denomina  depuración  
del  programa.  La  corrección  del  error  es  probablemente  la  
etapa  más  fácil,  siendo  la  detección  y  aislamiento  del  error  
las  tareas  más  di\ciles.    
•  Existen   diferentes   situaciones   en   las   cuales   se   suelen  
introducir   errores   en   un   programa.   Dos   de   las   más  
frecuentes  son:    
1.   Violación   (no   cumplimiento)   de   las   reglas   gramaFcales   del  
lenguaje  de  alto  nivel  en  el  que  se  escribe  el  programa.    
2.  Los  errores  en  el  diseño  del  algoritmo  en  el  que  está  basado  el  
programa.    
•  Cuando  el  compilador  detecta  un  error,  visualiza  un  
mensaje  de  error  indicando  que  se  ha  comeFdo  un  
error  y  posible  causa  del  error.    
•  Desgraciadamente  los  mensajes  de  error  son  di\ciles  
de  interpretar  y  a  veces  se  llegan  a  conclusiones  
erróneas.  También  varían  de  un  compilador  a  otro  
compilador.  A  medida  que  se  gana  en  experiencia,  el  
proceso  de  puesta  a  punto  de  un  programa  se  mejora  
considerablemente.    
•  Desde  el  punto  de  vista  conceptual  existen  tres  Fpos  
de  errores:  sintaxis,  lógicos  y  de  regresión.    
  
3.4.1.  Errores  de  sintaxis    
 
•  Los   errores   de   sintaxis   son   aquellos   que   se  
producen   cuando   el   programa   viola   la   sintaxis,   es  
decir,   las   reglas   de   gramáFca   del   lenguaje.  
Errores  de  sintaxis  apicos  son:    
–  escritura  incorrecta  de  palabras  reservadas,    
–  omisión   de   signos   de   puntuación   (comillas,   punto   y  
coma..  .).    
• Los  errores  de  sintaxis  son  los  más  fáciles  de  fijar,  
ya   que   ellos   son   detectados   y   aislados   por   el  
compilador.    
•  Si   el   programa   viola   alguna   de   estas   reglas,   el  
compilador   genera   un   mensaje   de   error   (o  
diagnós4co)  que  explica  el  problema  (aparente).    
•  A l g u n o s   e r r o r e s   a p i c o s   ( y a   c i t a d o s  
anteriormente):    
–  Punto  y  coma  después  de  la  cabecera  main(  ).  
–  Omisión  de  punto  y  coma  al  final  de  una  sentencia.  
–  Olvido  de  la  secuencia  */  para  finalizar  un  comentario.    
–  Olvido  de  las  dobles  comillas  al  cerrar  una  cadena.  
–  Etc.    
•  Si  una  sentencia  Fene  un  error  de  sintaxis  no  
se  traducirá   completamente  y  el  programa  no  
se   ejecutará.   Así   por   ejemplo,   si   una   línea   de  
programa  es    
double  radio    
•  se   producirá   un   error   ya   que   falta   el   punto   y  
coma  (;)  después  de  la  letra  úlFma  (o).    
  
3.4.2.  Errores  lógicos    
 
•  Un   segundo   Fpo   de   error   importante   es   el  
error   lógico,   ya   que   tal   error   representa  
errores   del   programador   en   el   diseño   del  
algoritmo  y  posterior  programa.    
•  Los   errores   lógicos   son   más   di\ciles   de  
encontrar   y   aislar   ya   que   no   suelen   ser  
detectados  por  el  compilador.    
•  Suponga  por  ejemplo  que  una  línea  de  un  programa  conFene  
la  sentencia    
 
double  peso  =  densidad  *  5.25  *  PI  *pow(longitud,5)/4.0;    
 
•  pero   resulta   que   el   tercer   asterisco   (operador   de  
mulFplicación)   debe   ser   en   realidad   un   signo   +(operador  
suma).    
•  El  compilador  no  produce  ningún  mensaje  de  error  de  sintaxis  
ya  que  no  se  ha  violado  ninguna  regla  de  sintaxis  y,  por  tanto,  
el   cornpilador   no   detecta   error   y   el   programa   se   compilará   y  
ejecutará   bien,   aunque   producirá   resultados   de   valores  
incorrectos   ya   que   la   fórmula   uFlizada   para   calcular   el   peso  
conFene  un  error  lógico.    
•  Una   vez   que   se   ha   determinado   que   un  
programa   conFene   un   error   lógico   en   la  
primera   ejecución   y   no   pasa   desapercibida   al  
programador,  encontrar  el  error  es  una  de  las  
tareas  más  di\ciles  de  la  programación.    
•  El   depurador   (debugger)   un   programa   de  
sohware   diseñado   específicamente   para   la  
detección,   verificación   y   corrección   de  
errores,  ayudará  en  las  tareas  de  depuración.  
•  Detéctalo  y  úsalo  en  tu  compilador.    
 Observación    
•  Se  pueden  detectar  errores  lógicos  comprobando  
el   programa   en   su   totalidad,   comprobando   su  
salida  con  los  resultados  previstos.    
•  Se   pueden   prevenir   errores   lógicos   con   un  
estudio   minucioso   y   detallado   del   algoritmo  
antes  de  que  el  programa  se  ejecute.    
•  Es   el   conocimiento   de   C,   de   las   técnicas  
algorítmicas   y   la   experiencia   lo   que   permiFrá   la  
detección  de  los  errores  lógicos.    
  
3.4.3.  Errores  de  regresión    
 
•  Los   errores   de   regresión   son   aquellos   que   se  
crean  accidentalmente  cuando  se  intenta  corregir  
un  error  lógico.    
•  Siempre   que   se   corrige   un   error   se   debe  
comprobar   totalmente   la   exacFtud   (corrección)  
para   asegurarse   que   se   fija   el   error   que   se   está  
tratando  y  no  produce  otro  error.    
•  Los   errores   de   regresión   son   comunes,   pero   son  
fáciles   de   leer   y   corregir.   Una   ley   no   escrita   es  
que:   un   error   se   ha   producido,   probablemente,  
por  el  úl>mo  código  modificación.    
  
3.4.4.  Mensajes  de  error    
• 
 
Los  compiladores  emiten  mensajes  de  error  o  de  advertencia  durante  las  
fases  de  compilación,  de  enlace  o  de  ejecución  de  un  programa.    
•  Los   mensajes   de   error   producidos   durante   la   compilación   se   suelen  
producir,   normalmente,   por   errores   de   sintaxis   y   suele   variar   según   los  
compiladores;  pero,  en  general,  se  agrupan  en  tres  grandes  bloques:    
–  Errores   fatales.   Son   raros.   Algunos   de   ellos   indican   un   error   interno  
del   compilador.   Cuando   ocurre   un   error   fatal,   la   compilación   se  
deFene   inmediatamente,   se   debe   tomar   la   acción   apropiada   y   a  
conFnuación  se  vuelve  a  iniciar  la  compilación.    
–  Errores   de   sintaxis.  Son   los   errores   apicos   de   sintaxis,   errores   de   línea  
de   órdenes   y   errores   de   acceso   a   memoria   o   disco.   El   compilador  
terminará  la  fase  actual  de  compilación  y  se  deFene.  
–  Advertencias(warning).No   impiden   la   compilación.   Indican  
condiciones  que  son  sospechosas,  pero  son  legíFmas  como  parte  del  
lenguaje.    
  
3.4.5.  Errores  en  Fempo  de  ejecución    
 
•  Existen  dos  Fpos  de  errores  en  >empo  de  ejecución:    
–  aquellos  que  son  detectados  por  el  sistema  en  Fempo  de  
ejecución  de  C      
–  aquellos   que   permiten   la   terminación   del   programa   pero  
producen  resultados  incorrectos.    
•  Un   error   en   Fempo   de   ejecución   puede   ocurrir   como  
resultado   de   que   el   programa   obliga   a   la   computadora   a  
realizar  una  operación  ilegal,  tal  como:  
–  dividir  un  número  por  cero,    
–  raíz  cuadrada  de  un  número  negaFvo  o    
–  manipular  datos  no  válidos  o  no  definidos.    
•  Cuando   ocurre   este   Fpo   de   error,   la   computadora  
detendrá   la   ejecución   de   su   programa   y   emiFrá  
(visualizará)  un  mensaje  de  diagnósFco  tal  como:    
 
Divide  error,  line  number  *  *    
 
•  Si  se  intenta  manipular  datos  no  válidos  o  indefinidos  su  
salida  puede  contener  resultados  extraños.  Por  ejemplo,  
se   puede   producir   un   desbordumiento   aritmé>co   cuando  
un  programa  intenta  almacenar  un  número  que  es  mayor  
que   el   tamaño   máximo   que   puede   manipular   su  
computadora.    
 
/  *  archivo  depurar  prueba  de  errores  en  Fempo  de  ejecución  */  
#include<stdio.h>  
#include  <conio.h>  
int  main()  
{  
 float  x,  y,  z;  /  *  Variables  locales  *  /    
 y  =  10.0;  
 z  =  x  +  y;  
 prinp("E1  valor  de  z  es  =  %f\n",z);    /  *  valor  inesperado:  error        de  ejecución  *  /  
 getche();  
 return  0;    
}  
•  El   programa   anterior,   sin   embargo,   podría   terminar   su  
ejecución,  aunque  produciría  resultados  incorrectos.  
•  Dado  que  no  se  asigna  ningún  valor  a  x,  contendrá  un  valor  
impredecible   y   el   resultado   de   la   suma   será   también  
impredecible.    
•  Muchos   compiladores   inicializan   las   variables  
automáFcamente  a  cero,  haciendo  en  este  caso  más  di\cil  
de  detectar  la  omisión,  sobre  todo  cuando  el  programa  se  
transfiere   a   otro   compilador   que   no   asigna   ningún   valor  
definido.    
•  Otra   fuente   de   errores   en   Fempo   de   ejecución   se   suele  
producir   por   errores   en   la   entrada   de   datos   producidos   por  
la  lectura  del  dato  incorrecto  en  una  variable  de  entrada.    
  
3.5.  PRUEBAS    
• 
 
Los   errores   de   ejecución   ocurren   después   que   el   programa  
se  ha  compilado  con  éxito  y  aún  se  está  ejecutando.  Existen  
ciertos   errores   que   la   computadora   sólo   puede   detectar  
cuando  se  ejecuta  el  programa.    
•  La  mayoría  de  los  sistemas  informáFcos  detectarán  ciertos  
errores  en  Fempo  de  ejecución  y  presentarán  un  mensaje  
de   error   apropiado.   Muchos   errores   en   Fempo   de  
ejecución  Fenen  que  ver  con  los  cálculos  numéricos.    
•  Por   ejemplo,   si   la   computadora   intenta   dividir   un   número  
por  cero  o  leer  un  archivo  no  creado,  se  produce  un  error  
en  Fempo  de  ejecución.    
•  Para   determinar   si   un   programa   conFene   un  
error  lógico,  se  debe  ejecutar  uFlizando  datos  de  
muestra   y   comprobar   la   salida   verificando   su  
exacFtud.    
•  Esta   prueba   (tes>ng)   se   debe   hacer   varias   veces  
uFlizando   diferentes   entradas   preparadas   en   el  
caso   ideal,   por   personas   diferentes   al  
programador,   que   puedan   indicar   suposiciones  
no   evidentes   en   la   elección   de   los   datos   de  
prueba.    
•  Si   cualquier   combinación   de   entradas   produce  
salida  incorrecta,  entonces  el  programa  conFene  
un  error  lógico.    
•  Una   vez   que   se   ha   determinado   que   un   programa  
conFene   un   error   lógico,   la   localización   del   error   es  
una  de  las  partes  más  di\ciles  de  la  programación.    
•  La   ejecución   se   debe   realizar   paso   a   paso   (seguir   la  
traza)   hasta   el   punto   en   que   se   observe   que   un   valor  
calculado  difiere  del  valor  esperado.    
•  Para  simplificar  este  seguimiento  o  traza,  la  mayoría  de  
los   compiladores   de   C   proporcionan   un   depurador  
integrado   incorporado   con   el   editor,   y   todos   ellos   en  
un   mismo   paquete   de   sohware,   que   permiten   al  
programador  ejecutar  realmente  un  programa,  línea  a  
línea,   observando   los   efectos   de   la   ejecución   de   cada  
línea  en  los  valores  de  los  objetos  del  programa.    
•  Una   vez   que   se   ha   localizado   el   error,   se   uFlizará   el  
editor  de  texto  para  corregir  dicho  error.    
•  A  medida  que  los  programas  crecen  en  tamaño  y  
complejidad,   el   problema   de   las   pruebas   se  
convierte   en   un   problema   de   dificultad   cada   vez  
más  creciente.    
•  No   importa   cuantas   pruebas   se   hagan:   “las  
pruebas  nunca  se  terminan,  sólo  se  deFenen  y  no  
existen   garanaas   de   que   se   han   encontrado   y  
corregido  todos  los  errores  de  un  programa”.    
•  Dijkstra   ya   predijo   a   principios   de   los   setenta   una  
máxima  que  siempre  se  ha  de  tener  presente  en  
la  construcción  de  un  programa:  Las  pruebas  sólo  
muestran   la   presencia   de   errores,   no   su   ausencia.  
No  se  puede  probar  que  un  programa  es  correcto  
(exacto)  sólo  se  puede  mostrar  que  es  incorrecto.    
 Programación estructurada
•  Es el conjunto de técnicas que incorporan:
–  Recursos abstractos,
–  Diseño descendente (top-down),
–  Estructuras básicas.
 
 Programación estructurada
•  Recursos abstractos: consiste en descomponer una
determinada acción compleja en acciones más
simples.
•  Diseño descendente (top-down): es el proceso
mediante el cual un problema se descompone en
una serie de niveles o pasos sucesivos de
refinamiento(stepwise).
•  Se descompone el problema en etapas o
estructuras jerárquicas.
•  Cada estructura tiene dos puntos de vista: ¿Qué
hace? y ¿Cómo lo hace?
 
 Programación estructurada
 
 
 
 
 
 
Diseño descendente (top-down)
 Programación estructurada
•  Considere un nivel n de refinamiento, las
estructuras se consideran de la siguiente
manera:
 

Nivel n: vista desde el exterior, Nivel n+1: vista desde el interior,

¿Qué hace? ¿Cómo lo hace?
Estructura básica de un programa en C

•  Comentarios (enunciado del programa)

•  Directivas del preprocesador
•  Declaraciones globales
•  función main()
•  Funciones definidas por el usuario    
 
Estructura básica de un programa en C
/*Aquí va la redacción del problema y la fecha siempre */
/* directivas del preprocesador */
/*Declaraciones globales de variables y funciones (sus prototipos)*/

/* Función principal main( ) */

void main( )
{
/*declaraciones de variables locales*/
sentencias;
}
/* definiciones de funciones creadas por el usuario programador */
tipo nombre_función(parámetros)
{ /*declaraciones de variables locales; */
sentencias;
}
 Ejemplo
/* Programa que imprime un mensaje de bienvenida y
nombre*/
#include <stdio.h>
#include <conio.h>
Int main()
{
printf(“ \n\n\n \t\tBienvenido al curso de
programación en C :”);
printf(“ \n \t\t\t\tMaryLu Juárez “);
getche();
return 0;
}
 
 Bibliotecas estándar de C
•  Todas las versiones del lenguaje C ofrecen una
biblioteca estándar de funciones en tiempo de
ejecución que proporcionan soporte para
operaciones utilizadas con mas frecuencia.

•  Estas funciones permiten realizar una operación

con solo una llamada a la función (sin necesidad
de escribir su código fuente).
 
 Bibliotecas estándar de C
•  Las funciones estándar o predefinidas se
dividen en grupos; todas las funciones que
pertenecen al mismo grupo se declaran en el
mismo archivo de cabecera.

•  Los nombres de los archivos de cabecera

estándar utilizados en nuestros programa se
muestran a continuación encerrados entre
ángulos:
 
 Archivos  de  cabecera  

<assert.h> <ctype.h> <errno.h> <float.h>

<limits.h> <math.h> <setjmp.h> <signal.h>
<stdarg.h> <stdef.h> <stdio.h> <string.h>
<time.h> <stdlib.h> <conio.h>
 Archivos de cabecera
•  Algunos de los grupos de funciones de biblioteca
más usuales son:
•  E/S estándar (para operaciones de entrada/
salida);
•  Matemáticas (para operaciones matemáticas);
•  Fecha y hora;
•  De interfaz;
•  Diversas;
•  Manipulación de cadenas;
•  Gráficos.
 
 DirecFvas    
•  Son instrucciones que se le dan al compilador antes
de que el programa se compile.
•  Aunque las directivas pueden definir macros,
nombres de constantes, archivos fuente adicionales,
etc., su uso más frecuente en C es la inclusión de
archivos de cabecera.
•  Las directivas no son instrucciones de programa
sino instrucciones que se dan al compilador,
obsérvese que su línea no termina en punto y
coma ;.
 Directiva #include
•  Para utilizar una función de biblioteca se hace
mediante la directiva del preprocesador
#include:
•  Formato:

#include <nombreArchivo>
 
 Comentarios    
•  Un  comentario  es  un  breve  enunciado  para  
documentar  una  línea  del  programa.  Son  
necesarios  porque  es  la  documentación  del  
programa  fuente.  
•  Un  comentario  en  C  se  encierra  entre  /*  y  */.  
Puede  contener  cualquier  canFdad  de  líneas.  
•  También  puede  uFlizar  //  para  comentarios  de  
una  sola  línea  ya  que  el  compilador  uFlizado  
es  de  C++.  
 Ejemplos
•  /* Este es un ejemplo de un comentario en
lenguaje C y contiene dos líneas */

•  //ejemplo de un comentario de C++

•  //Solo puede contener una línea

•  //solamente se usan al principio del comentario

 IdenFficadores    
•  Un identificador es una secuencia de caracteres,
para dar nombres a variables, constantes,
funciones, etc.
•  El primer caracter debe ser una letra o caracter
de subrayado. Las letras mayúsculas son
diferentes de las minúsculas.
•  Pueden seguirle más letras, números y
subrayado.
 Ejemplos
•  I
•  indice
•  dia_de_vencimiento
•  elemento_mayor
•  cantidad_total
•  fecha_de_compra
•  habitacion120
•  A
•  Alfa
•  ALFA
•  alfa
 
 Palabras clave
•  Las   palabras   clave   son   propias   del   lenguaje   por   lo  
que  no  pueden  uFlizarse  como  idenFficadores.  
•  Las   palabras   clave   deben   escribirse   con   minúsculas  
por   lo   que   si   se   desea   escribir   un   idenFficador   con   el  
nombre  de  una  palabra  clave,  éste  debe  contener  al  
menos  una  mayúscula  para  diferenciarlo.  
 Palabras  clave  

and do int short typed

auto double long signed union
bool else namespace sizeof unsigned
break enum new static using
case extern not struct virtual
catch false operator switch void
char float or template wchar_t
class for private this while
const friend protected throw xor
continue goto public true
default if register try
delete inline return typedef
 Tipos de datos numéricos
Rango
Tipo Ejemplo Tamaño en bytes
Mínimo..Máximo
char ‘C’ 1 0..255
short -15 2 -128..127
int 1024 2 -32768..32767
unsigned int 42325 2 0..65535
short int -100 2 -128..127
-2147483648..21474
long 262144 4
83637
usigned long 4085466200 4 0..4294967295
float 10.5 4 3.4e-38..3.4e38
double 0.00045 8 1.7e-308..1.7e308
long double 1e-8 8 Igual que double
  
3.9.  CONSTANTES    
 
•  Son   datos   que   no   cambian   durante   la  
ejecución  de  un  programa.    
•  En  C  existen  cuatro  Fpos  de  constantes:    
–  constantes  literales,  
–  Constantesdefinidas,  
–  constantes  enumeradas,    
–  constantes  declaradas.    
•  Las   constantes   literales   son   las   más   usuales;   toman  
valores  tales  como    
–  45  .32564,222  o  bien  "Introduzca  sus  datos"    
que  se  escriben  directamente  en  el  texto  del  programa.  
 
•  Las   constantes   definidas   son   idenFficadores   que   se  
asocian   con   valores   literales   constantes   y   que   toman  
determinados  nombres.    
•  Las   constantes   declaradas   son   como   variables:   sus  
valores   se   almacenan   en   memoria,   pero   no   se   pueden  
modificar.    
•  Las   constantes   enumeradas   permiten   asociar   un  
idenFficador,   tal   como   Color,   con   una     secuencia   de  
otros  nombres,  tales  como  Azul,  Verde,  Rojo  y  Amarillo.    
  
3.9.1.  Constantes  literales    
 
•  Las  constantes  literales  o  constantes,  en  
general,  se  clasifican  también  en  cuatro  
grupos,  cada  uno  de  los  cuales  puede  ser  de  
cualquiera  de  los  Fpos:    
–  constantes  enteras,  
–  constantes  caracteres,  
–  constantes  de  coma  flotante,    
–  constantes  de  cadena.    
 Constantes numéricas
•  Enteras pueden escribirse en decimal, hexadecimal u octal.
•  Decimal – secuencias de dígitos decimales con o sin signo
(+, -).
Ejemplo: 5 -23 1234 30689

•  Hexadecimal – secuencias de dígitos hexadecimales (0..9,

a..f, o A..F) que inicia con 0x.
Ejemplo: 0x00ff o 0x00FF = 255 (decimal)

•  Octal – secuencias de dígitos octales (0..7) que inicia con

0.
Ejemplo: 0456 = 302 (decimal)
 Constantes numéricas  
•  Reales se especifican como secuencias de dígitos decimales y el
punto decimal.
•  Ejemplo: 3.1416 -6.4567 0.625 -5.0

•  Los números en notación científica se expresan indicando el

multiplicador de 10 mediante E+nn o e+nn.
•  Ejemplo: 12.4 x 104 = 12.4E+4 o 12.4E4
  
Constantes  caracter    
 
•  Una   constante   caracter   (char)   es   un   caracter   del  
código  ASCII  encerrado  entre  apóstrofes.    
'A’      'b’      'C'    
•  Además   de   los   caracteres   ASCII   estandar,   una  
constante   caracter   soporta   caracteres   especiales  
que   no   se   pueden   representar   uFlizando   su  
teclado,   como,   por   ejemplo,   los   códigos   ASCII  
altos   y   las   secuencias   de   escape.   (El   Apéndice   B  
recoge  un  listado  de  todos  los  caracteres  ASCII.)    
•  Así,  por  ejemplo,  el  carácter  sigma  (Σ),  código  
ASCII   228,   hex   E4   se   representa   mediante   el  
prefijo  \x  y  el  número  hexadecimal  del  código  
ASCII.  Por  ejemplo:    
char  sigma  =  '\xE4';    
•  Este   método   se   uFliza   para   almacenar   o  
imprimir   cualquier   caracter   de   la   tabla   ASCII  
por  su  número  hexadecimal.    
•  En   el   ejemplo   anterior,   la   variable   sigma   no  
conFene   cuatro   caracteres   sino   únicamente   el  
símbolo  sigma.    
  
AritméFca  con  caracteres  C    
 
•  Dada   la   correspondencia   entre   un   carácter   y   su  
código   ASCII,   es   posible   realizar   operaciones  
aritméFcas   sobre   datos   de   caracteres.   Observe   el  
siguiente  segmento  de  código:    
     char  c;  
     c  =  'T’  +    5;  /*  suma  5  al  caracter  ASCII  */    
•  Realmente   lo   que   sucede   es   almacenar   Y   en   la  
variable   c.   El   valor   ASCII   de   la   letra   T   es   84,   y   al  
sumarle  5  produce  89,  que  es  el  código  de  la  letra  
Y.    
       
•  A  la  inversa,  se  pueden  almacenar  constantes  
de  caracter  en  variables  enteras.  Así:  
 
int  j  =  'p’;  
 
•  No  pone  una  letra  p  en  j  ,  sino  que  asigna  el  
valor  80  (código  ASCII  de  p)  a  la  variable  j.  
 
  
Constantes  cadena    
 
•  Una  constante  cadena  (también  llamada  
literal  cadena  o  simplemente  cadena)  es  una  
secuencia  de  caracteres  encerrados  entre  
dobles  comillas.    
•  Algunos  ejemplos  de  constantes  de  cadena  
son:    
   "123"  
   "12  de  octubre  1492"    
   "esto  es  una  cadena"    
•  En  memoria,  las  cadenas  se  representan  por  
una  serie  de  caracteres  ASCII  más  un  0  o  nulo.  
El  caracter  nulo  marca  el  final  de  la  cadena  y  
se  inserta  automáFcamente  por  el  compilador  
C  al  final  de  las  constantes  de  cadenas.    
•  Para  representar  valores  nulos,  C  define  el  
símbolo  NULL  como  una  constante  en  diversos  
archivos  de  cabecera  (normalmente  stdef.h,  
stdio.h,  stdlib.h  y  string.h).    
 
•  Para   uFlizar   NULL   en   un   programa,   incluya  
uno   o   más   de   estos   archivos   en   lugar   de  
definir  NULL  con  una  línea  tal  como    
#define  NULL    0  
•  Recuerde  que  una  constante  de  caracteres  se  
encierra   entre   comillas   simples   (apóstrofe),   y  
las  constantes  de  cadena  encierran  caracteres  
entre  dobles  comillas.  Por  ejemplo:    
'Z'          “Z"    
•  El  primer  Z  es  una  constante  caracter  simple  
con  una  longitud  de  1,  y  el  segundo  “Z”  es  una  
constante  de  cadena  de  caracteres  también  
con  la  longitud  1.    
•  La  diferencia  es  que  la  constante  de  cadena  
incluye  un  cero  (nulo)  al  final  de  la  cadena,  ya  
que  C  necesita  conocer  dónde  termina  la  
cadena,  y  la  constante  caracter  no  incluye  el  
nulo  ya  que  se  almacena  como  un  entero.    
 
  
3.9.2.  Constantes  definidas  (simbólicas)    
 
•  Las  constantes  pueden  recibir  nombres  
simbólicos  mediante  la  direcFva  #define.    
   #define  NUEVALINEA      \n    
   #define  PI      3.141592    
   #define  VALOR      54    
•  C  susFtuye  los  valores  \n,  3.141592  y  54  cuando  
se   encuentra   las   constantes   simbólicas  
NUEVALINEA,  P  I  y  VALOR  en  el  progrma.  
•  Las  líneas  anteriores  no  son  sentencias  y  por  ello,  
no  terminan  en  punto  y  coma.    
 
prin\("El  valor    %d  es  NUEVALINEA",  VALOR);  
 
•  Escribe   en   pantalla   la   constante   VALOR.  
Realmente,   el   compilador   lo   que   hace   es   susFtuir  
en   el   progama   todas   las   ocurrencias   de   VALOR  
por   54,   antes   de   analizar   sintácFcamente   el  
programa  fuente.    
  
3.9.3.  Constantesenumeradas    
 
•  Las  constantes  enumeradas  permiten  crear  listas  de  
elementos  afines.  Un  ejemplo  apico  es  una  constante  
enumerada  de  lista  de  colores,  que  se  puede  declarar  
como:    
 
enum  Colores  {Rojo,  Naranja,  Amarillo,  Verde,  Azul,  Violeta};    
 
•  Cuando  se  procesa  esta  sentencia,  el  compilador  
asigna  un  valor  que  comienza  en  0  a  cada  elemento  
enumerado;  así,  Rojo  equivale  a  0,  Naranja  es  1,  etc.  
•  El  compilador  enumera  los  idenFficadores  por  usted.    
•  Después  de  declarar  un  Fpo  de  dato  
enumerado,  se  pueden  crear  variables  de  ese  
Fpo,  como  con  cualquier  otro  Fpo  de  datos.    
•  Así,  por  ejemplo,  se  puede  definir  una  variable  
de  Fpo  enum  colores.    

enum  Colores  Colorfavorito  =  Verde;    

•  Otro  ejemplo  puede  ser:  
 
enum  Boolean  {  False,  True  }  ;    
 
•  que  asignará  al  elemento  False  el  valor  0  y  a  
True  el  valor  1.    
•  Para  crear  una  variable  de  Fpo  lógico  declarar:  
   
enum  Boolean  Interruptor  =  True;    
 
•  Es  posible  asignar  valores  disFntos  de  los  que  les  
corresponde  en  su  secuencia  natural    
 
enum  LucesTrafico  {Verde,  Amarillo  =  10,  Rojo};    
 
•  Al  procesar  esta  sentencia,  el  compilador  asigna  
el  valor  0  al  idenFficador  verde,  10  al  
idenFficador  amarillo  y  11  al  Rojo.    
  
3.9.4.  Constantes  declaradas  const  y  volaFle  
 
 
•  El  cualificador  const  permite  dar  nombres  
simbólicos  a  constantes  a  modo  de  otros  
lenguajes,  como  Pascal.    
•  El  formato  general  para  crear  una  constante  es:    
const    Fpo    idenFficador  =  valor;    
 
•  si  se  omite  Fpo,  C  uFliza  int  (entero  por  defecto)  
 
  const  int  Meses  =  12;  
 const  char  CARÁCTER  =  '@';  
 const  int  OCTAL  =    0233;  
 const  char  CADENA  [  ]  =  "Curso  de  C";    
•  C  soporta  el  calificador  de  Fpo  variable  const.  
•  Especifica   que   el   valor   de   una   variable   no   se  
puede  modificar  durante  el  programa.    
•  Cualquier   intento   de   modificar   el   valor   de   la  
variable   definida   con   const   producirá   un  
mensaje  de  error.    
•  La   palabra   reservada   voiadie   actúa   como  
const,  pero  su  valor  puede  ser  modificado  no  
sólo  por  el  propio  programa,  sino  también  por  
el  hardware  o  por  el  soMware  del  sistema.    
•  Las   variables   voláFles,   sin   embargo,   no   se  
pueden  guardar  en  registros,  como  es  el  caso  
de  las  variables  normales.    
  
Diferencias  entre  const  y  #define    
 
•  Las  definiciones  const  especifican  Fpos  de  
datos,  terminan  con  puntos  y  coma  y  se  
inicializan  como  las  variables.    
•  La  direcFva  #define  no  especifica  Fpos  de  
datos,  no  uFlizan  el  operador  de  asignación  
(=)  y  no  termina  con  punto  y  coma.    
  
Ventajas  de  const  sobre  #define  
• 
 
En  C  casi  siempre  es  recomendable  el  uso  de  const  en  lugar  de  
considerar  otras:      
#define.  Además  de  las  ventajas   ya  enunciadas  se  pueden  

•  El  compilador,  normalmente,  genera  código  más  eficiente  con  

constantes  const  .  
 
•  Como  las  definiciones  especifican  Fpos  de  datos,  el  compilador  
puede  comprobar  inmediatamente  si  las  constantes  literales  en  las  
definiciones  de  const  están  en  forma  correcta.    
•  Con  #define  el  compilador  no  puede  realizar  pruebas  similares  
hasta  que  una  sentencia  uFliza  el  idenFficador  constante,  por  lo  
que  se  hace  más  di\cil  la  detección  de  errores.    
  
Desventaja  de  const  sobre  #define    
 
•  Los  valores  de  los  símbolos  de  const  ocupan  
espacio  de  datos  en  Fempo  de  ejecución,  
mientras  que  #define  sólo  existe  en  el  texto  del  
programa  y  su  valor  se  inserta  directamente  en  el  
código  compilado.    
•  Los  valores  const  no  se  pueden  uFlizar  donde  el  
compilador  espera  un  valor  constante,  por  
ejemplo  en  la  definición  de  un  array.    
•  Por  esta  razón,  algunos  programadores  de  C  
siguen  uFlizando  #define  en  lugar  de  const.    
 3.10 Variables
•  Es un espacio en la memoria principal de la
computadora para almacenar un dato, se le nombra con
un identificador y puede cambiar su valor durante la
ejecución de un programa.
•  En C es necesario declarar todas las variables que se
utilicen antes de ser utilizadas.
•  Sintaxis de la declaración:
tipo_dato identificador_de_variable ;
Ejemplos:
int numero; /*Declara numero de tipo entero*/
float x, y; /*Declara x y y s de tipo real*/
  
3.10.2.  Inicialización  de  variables    
 
Tipo    nombre-­‐varíable    =    expresión;  
 
•  expresión  es  cualquier  expresión  válida  cuyo  
valor  es  del  mismo  Fpo  de  dato  que  4po.    
•  Nota:  esta  sentencia  declara  y  proporciona  un  
valor  inicial  a  una  variable  
 
•  Las  variables  se  pueden  inicializar  a  la  vez  que  
se  declaran,  o  bien,  inicializarse  después  de  la  
declaración.    
•  El  primer  método  es  probablemente  el  mejor  
en  la  mayoría  de  los  casos,  ya  que  combina  la  
definición  de  la  variable  con  la  asignación  de  
su  valor  inicial.    
   char  respuesta  =  'S';    
   int  contador  =  1;    
   float  peso  =  156.45;    
   int  anio  =  1993;    
•  Estas   acciones   crean   variables   respuesta,  
contador,   peso   y   anio,   que   almacenan   en  
memoria  los  valores  respecFvos  situados  a  su  
derecha.    
•  El   segundo   método   consiste   en   uFlizar  
sentencias   de   asignación   diferentes   después  
de   definir   la   variable,   como   en   el   siguiente  
caso:    
char  barra;    
barra=  ‘/  ‘  ;    
  
3.11.  DURACIÓN  DE  UNA  VARIABLE    
• 
 
Dependiendo   del   lugar   donde   se   definan   las   variables   de   C,  
éstas   se   pueden   uFlizar   en   la   totalidad   del   programa,  
dentro   de   una   función   o   pueden   exisFr   sólo  
temporalmente  dentro  de  un  bloque  de  una  función.    
•  La  zona  de  un  programa  en  la  que  una  variable  está  acFva  
se  denomina,  normalmente,  ámbito  o  alcance  («scope»).    
•  El   ámbito   (alcance)   de   una   variable   se   exFende   hasta   los  
límites  de  la  definición  de  su  bloque.    
•  Los  Fpos  básicos  de  variables  en  C  son:    
–  variables  locales;    
–  variables  globales;    
–  variables  dinámicas.    
  
3.11.1.  Variables  locales    
• 
 
Las  variables  locales  son  aquéllas  definidas  en  el  interior  de  
una  función  y  son  visibles  sólo  en  esa  función  específica.  
•  Las  reglas  por  las  que  se  rigen  las  variables  locales  son:    
1.  En  el  interior  de  una  función,  una  variable  local  no  puede  ser  
modificada  por  ninguna  sentencia  externa  a  la  función.    
2.  Los   nombres   de   las   variables   locales   no   han   de   ser   Únicos.  
Dos,  tres  o  más  funciones  pueden  definir  variables  de  nombre  
Interruptor:  Cada  variable  es  disFnta  y  pertenece  a  la  función  
en  que  está  declarada.    
3.  Las  variables  locales  de  las  funciones  no  existen  en  memoria  
hasta   que   se   ejecuta   la   función.   Esta   propiedad   permite  
ahorrar   memoria,   ya   que   permite   que   varias   funciones  
compartan   la   misma   memoria   para   sus   variables   locales   (pero  
no  a  la  vez).    
•  Por   la   razón   dada   en   el   punto   3,   las   variables   locales   se  
llaman   también   automá>cas   o   auto,   ya   que   dichas  
variables   se   crean   automáFcamente   en   la   entrada   a   la  
función   y   se   liberan   también   automáFcamente   cuando   se  
termina  la  ejecución  de  la  función.    
#include  <stdio.h>  
int    X;  //ejemplo  de  variable  global  fuera  de  las  funciones  
 int  main()    
{  
   int  num1  =0,  num2  =  0  suma  =  0;  //variables  locales  de  main  
   prinp  (  ”Ingrese  los  valores  de  a  y  b    a  sumar:  “);  
   scanf("%d%d",&num1,  num2);    
   suma  =    a+b;      
   return    0;    
}  
•  Todas   las   variables   locales   desaparecen   cuando  
termina  su  bloque.    
•  Una   variable   global   es   visible   desde   el   punto   en   que   se  
define  hasta  el  final  del  programa  (archivo  fuente).    
•  La   memoria   asignada   a   una   variable   global   permanece  
asignada   a   través   de   la   ejecución   del   programa,  
tomando   espacio   válido   según   se   u>lice.   Por   esta  
razón,   se   debe   evitar   u>lizar   muchas   variables   globales  
dentro  de  un  programa.  Otro  problema  que  surge  con  
variables  globales  es  que  una  función  puede  asignar  un  
valor  específico  a  una  variable  global.  Posteriormente,  
en  otra  función,  y  por  olvido,  se  pueden  hacer  cambios  
en   la   misma   variable.   Estos   cambios   dificultarán   la  
localización  de  errores.    
 
  
3.11.3.  Variables  dinámicas    
•  Las  
 
variables   dinbmicns   Fenen   caracterísFcas   que   en  
algunos  casos  son  similares  tanto  a  variables  locales  como  a  
globales.    
•  AI   igual   que   una   variable   local,   una   variable   dinámica   se  
crea   y   libera   durante   la   ejecución   del   programa.   La  
diferencia  entre  una  vuriable  local  y  una  variable  dinámica  
es  que  la  variable  dinámica  se  crea  tras  su  peFción  (en  vez  
de  automáFcamente,  como  las  variables  locales),  es  decir,  
a  su  voluntad,  y  se  libera  cuando  ya  no  se  necesita.  
•  AI  igual  que  una  variable  global,  se  pueden  crear  variables  
dinámicas  que  son  accesibles  desde  múlFples  funciones.    
•  Las   variables   dinámicas   se   examinan   en   detalle   en   el  
capítulo  de  punteros  (Capítulo  10).    
 Operadores    
•  C  es  un  lenguaje  muy  rico  en  operadores.  Se  
clasifican  en  los  siguientes  grupos:    
•  AritméFcos
•  Relacionales  y  lógicos  
•  Asignación  
•  Manipulación  de  bits  
•  Otros    
 
 Operaciones  aritméFcas  
•  Para  poder  realizar  operaciones  aritméFcas  
necesitamos  de  operadores  aritméFcos.    
•  Estos  operadores  nos  permiten  realizar  
operaciones  aritméFcas  entre  operandos  
numéricos:  constantes  o  variables.    
•  El  resultado  de  una  operación  aritméFca  es  un  
número.    
 Operación de asignación
•  La operación básica para el uso de variables es la
asignación
•  El tipo de constante a asignar debe de ser congruente
con el tipo de dato con el que fue declarada la variable.
•  Para la asignación se utiliza el símbolo =
•  Ejemplos:
a = 5;
b = 8;
 Ejemplo
//Ejemplo de uso de variables y operador de asignación
#include <stdio.h>
#include <conio.h>
int main()
{
int a,b,c,d; //4 variables enteras
a = 45;
b = 23;
c = 368;
d = 345;

printf("Impresión de \"variables\"\n”);
printf(”a= %d\t b=%d \t c=%d \t d=%d”,a,b,c,d);
getche();
return 0;
}

Impresión de "variables"
Salida a= 45 b=23 c=368 d=345
 Operadores  aritméFcos  
Operador   Nombre   Propósito   Ejemplo  
+   Más unario (positivo)   Valor positivo de x   x = +y;  
Menos unario
-   Valor negativo de x   x = -y;  
(negativo)  
+   Suma   Suma x e y   z = x + y;  
-   Resta   Resta y de x   z = x – y;  
*   Multiplicación   Multiplica x por y   z = x * y;  
/   División   Divide x por y   z = x / y;  
Resto de x dividido
%   Módulo   z =x % y  
por y  
Incrementa x después
++   Incremento en 1   x++;  
de usar  
Decrementa x antes de
--   Decremento en 1   --x;  
usar  
 Operadores de incremento y decremento

variable++; //posincremento
++variable; //preincremento
variable--; //posdecremento
--variable; //predecremento
Ejemplos:
++x; equivale a x = x + 1;
--x; equivale a x = x – 1;
•  Los formatos postfijos se comportan de modo diferente según
la expresión en que se aplica:
•  x = ++y; equivale a x = y + 1; x = y; //x igual a y incrementado
•  x = y++; equivale a x = y; y = y + 1; /* x igual al valor de y sin
incrementar*/
Ejemplos    
 Operadores relacionales
•  Los operadores relacionales se utilizan para construir
expresiones que determinan la toma de decisiones en
un lenguaje de programación.
Operador   Nombre   Ejemplo  
<   Menor que   I < 0  
<=   Menor o igual que   I <= 0  
>   Mayor que   J > 50  
>=   Mayor o igual que   J >= 8.5  
==   Igual a   X == 10  
!=   Diferente que   C != ‘*’  
?:   Asignación relacional   K = (i < 5)? 1 : i;  
 Operadores relacionales

•  Formato: expresión1 operador expresión2

•  Donde expresión1 y expresión2 pueden ser

una constante, una variable o un conjunto de
ellas unidas por operadores aritméticos.
 Operadores lógicos
•  Los operadores lógicos se utilizan para unir expresiones
relacionales que determinan la toma de decisiones en
un lenguaje de programación.

Operador   Nombre   Ejemplo  

&&   AND (y) lógico   A && B  
||   OR (o) lógico   C || D  
!   NOT (no) lógico   !C  
 Operadores  lógicos  
•  Formato: expresión1 operador expresión2

•  Donde  expresión1  y  expresión2  son  

expresiones  relacionales.  
 Operador condicional ?:
•  Formatos:

1.  (condición) ? expresión1 : expresión2;

•  Expresión1 y expresión2 pueden ser cualquier
instrucción que se quiera ejecutar (una solamente)

2. Variable = (condición) ? expresión1 : expresión2;

•  La expresión condicional comprueba la condición. Si esa
condición es verdadera, se asigna expresión1 a variable;
en caso contrario se asigna expresión2 a variable.
 Evaluaciones booleanas
•  Cuando se evalúan expresiones lógicas el resultado
será un valor booleano (falso o verdadero) de acuerdo al
operador lógico utilizado

Expresión Expresión
A && B   A || B  
A   B  
1   1   1   1  
1   0   0   1  
0   1   0   1  
0   0   0   0  
 Operadores de asignación
•  C proporciona operadores de asignación que
combinan operadores de asignación y otros
diferentes produciendo operadores tales como:

Operador   Formato largo   Formato corto  

+=   x = x + y;   x += y;  
-=   x = x – y;   x -= y;  
*=   x = x * y;   x *= y;  
/=   x = x / y;   x /= y;  
%=   x = x % y;   x %= y;  
 Operadores de asignación
•  Ejemplos:
•  A += b; equivale a A = A + b
•  A *= A + b; equivale a A * (A +b)
•  Expresiones equivalentes:
•  n = n + 1;
•  n += 1;
•  n++;
•  ++n;
 Prioridad  y  asociaFvidad  
Operador   Asociatividad   Prioridad  
()   Izquierda-derecha   1  
- +(unarios) ! ++ --   Derecha-izquierda   2  
*/%   Izquierda-derecha   3  
+-   Izquierda-derecha   4  
< <= > >=   Izquierda-derecha   5  
== !=   Izquierda-derecha   6  
&&   Izquierda-derecha   7  
||   Izquierda-derecha   8  
?:   Derecha-izquierda   9  
= += -= *= %= /=   Derecha-izquierda   10  
 Conversiones de tipo (Casting)
•  Es un proceso que convierte un tipo de dato a
otro tipo de dato.
•  Tipos de casting: —
–  Implícito
–  Explícito
 
 Conversiones de tipo (Casting)  
•  Casting implícito:
•  Se realiza de forma automática cuando un tipo de menor
capacidad se asigna a un tipo de mayor capacidad, también
llamado promoción numérica.
•  byte -> short -> int -> long -> float -> double
•  Ejemplo:
double n;
int x = 7;
n = x / 3; n = 2.0
(se realizó la conversión de tipos, el resultado está en formato
double pero no se muestran las decimales significativas)
 Conversiones de tipo (Casting)  
•  Casting explícito:
Es necesario utilizar un operador de tipo cast.
•  Formato:
(tipoDato) expresión
•  Ejemplo:
double n;
int a = 7;
n = (double) a / 3;
n = 2.333
(se realizó el casting explísito por lo que sí se mostrarán
las decimales significativas)
 Conversiones de tipo (Casting)  
int x = 6, y = 10;
double cociente;
•  Como solución se usaría la siguiente conversión
de tipo:
cociente = (double) x / y;
(debe realizarse casting explícito ya que la
división de dos valores enteros da como resultado
un entero por lo que se almacenaría en la variable
cociente solo la parte entera del resultado, esto es
0 y no 0.6)
 Conversiones de tipo (Casting)  
•  ¿Cuál de las siguientes formas es la forma
correcta de realizar el casting y por qué?
a) int n;
double x = 2.1;
n = x;
b) int n;
double x = 2.1;
n = (int) x;
Ejemplos  de  programas  
secuenciales  
UFlizando  los  conceptos  vistos  en  
clase  
  
ENTRADAS  Y  SALIDAS    
• 
 
Los   programas   interactúan   con   el   exterior,   a   través   de  
datos  de  entrada  o  datos  de  salida.  
•    La   biblioteca   C   proporciona   facilidades   para   entrada   y  
salida,  para  lo  que  todo  programa  deberá   tener  el  archivo  
de  cabecera  stdio.h  .    
•  En  C  la  entrada  y  salida  se  lee  y  escribe  de  los  disposiFvos  
estándar  de  entrada  y  salida,  se  denominan  stdin  y  stdout  
respecFvamente.    
•  La   salida   normalmente   es   a   pantalla   y   la   entrada   se   capta  
del  teclado  de  la  computadora.  
•  En   el   archivo   stdio.h   están   definidas   macros,   constantes,  
variables  y  funciones  que  permiten  intercambiar  datos  con  
el  exterior  
 Salida  con  función  prinW()  
•  La  salida  de  datos  de  un  programa  se  puede  
dirigir  a  diversos  disposiFvos,  pantalla,  
impresora,  archivos.    
•  La  salida  que  se  trata  a  conFnuación  va  a  ser  a  
pantalla,  además  será  formateada.    
•  La  función  prinp()  visualiza  en  la  pantalla  
datos  del  programa,  transforma  los  datos,  que  
están  en  representación  binaria  a  ASCII  según  
los  códigos  transmiFdos.    
 Ejemplo    
 suma  =  0;  
 suma  =  suma+  10;  
 prinp  ("%s  %d",  "Suma  =    “  ,  suma);    
•  Visualiza  en  pantalla:  
 Suma  =  10    
 
•  El  número  de  argumentos  de  prinp()  es  
indefinido,  por  lo  que  se  pueden  trasmiFr  
cuantos  datos  se  desee.  Así,  suponiendo  que    
 1  =  5      j  =  12    c  =  'A'    n  =  40.791512    
•  la  sentencia    
   prinp("%d  %d  %c  %f  ”,i,  j,c,n);    
•  visualizará  en  la  pantalla:    
 5    12      A      40.791512    
 
 sintaxis  
 
prinC(  “cadena_de_control  ”,  dato1,  dato2,....);  
 
•  La  “cadena_de_control”  conFene  códigos  de  
formato,  caracteres  comunes  y  secuencias  de  
escape.    
•  dato1,  dato2,  ....  Son  variables,  constantes,  
expresiones.    
 Códigos  de  formato  
•  Se  usan  para  dar  formato  a  las  salidas:    
 
%d     el  dato  se  convierte  a  entero  decimal.    

%o     El  dato  entero  se  convierte  a  octal.    

%x     El  dato  entero  se  convierte  a  hexadecimal.    

%ld     El  dato  se  considera  de  Fpo  long.    

%u     El  dato  se  convierte  a  entero  sin  signo.    

%c     El  dato  se  considera  de  Fpo  carácter.    

%e     El  dato  se  considera  de  Fpo  float.  Se  convierte  a  notación  cienafica,  de  la  forma  {-­‐}[Link]{+/-­‐}dd.    

El  dato  se  considera  de  Fpo  float.  Se  convierte  a  notación  decimal,  con  parte  entera  y  los  dígitos  de  
%f    
precisión.    
El  dato  se  considera  de  Fpo  float.  Se  convierte  según  el  código  %e  o  %f  dependiendo  de  cual  sea  la  
%g    
representación  más  corta.    

%s     El  dato  ha  de  ser  una  cadena  de  caracteres.    

%lf     El  dato  se  considera  de  Fpo  double.    

 Códigos  de  formato  
•  El  código  comienza  con  el  caracter  %,  a  conFnuación  
puede  especificarse  el  ancho  mínimo  del  dato  y  
termina  con  el  caracter  de  conversión:    
•  i  =  11  j  =  12  c  =‘A’,  n  =  40.791512    
prinp(“  %x,  %3d,  %c  %.3f  ”,  i,  j,  c,  n);    
•  visualizará  en  la  pantalla:    
 B,  12  ,  A  40.792    
•  El  primer  dato  es  11  en  hexadecimal  equivale  a  la  letra  
B  (%x),  el  segundo  es  el  número  entero  12  en  un  ancho  
de  campo  3,  le  sigue  el  caracter  A  y  por  úlFmo,  el  
número  real  n  redondeado  a  3  cifras  decimales  (%.3f)    
•  Un  signo  menos  a  conFnuación  de  %  indica  que  el  dato  se  ajuste  a  la  
izquierda  en  vez  del  ajuste  a  la  derecha  por  defecto.  

prinp(“  %15s  ”,  “HOLA”  );    

prinp(“  %-­‐15s  ”,  “HOLA”  );  
 
visualizará  en  pantalla:  
   HOLA  
HOLA  
 Secuencias  de  escape  
•  Las  secuencias  de  escape  producen  en  las  aplicaciones  efectos  
especiales.    
Código  de  escape     Significado    
  \n     Nueva  línea    
\r     Retorno  de  carro    
\t     Tabulación    
\v     Tabulación  verFcal    
\a     Alarma    
\b     Retroceso  de  espacio    
\f     Avance  de  página    
\\     Barra  inclinada  inversa    
\‟     Comilla  simple    
\”     Dobles  comillas    
\?     Signo  de  interrogación    
\000     Número  octal    
\xhh     Número  hexadecimal    
\0     Cero,  nulo  (ASCII  0)    
 Secuencias  de  escape  
•  Puede  uFlizar  las  secuencias  de  escape  en  cualquier  parte  de  su  cadena  de  
control:    
 
prin\(“  Este  es  un  ejemplo\n  de  secuencia  de  escape\n  salto  de  línea.\n”);    
 
visualiza  en  pantalla:  
 
Este  es  un  ejemplo  
de  secuencia  de  escape  
salto  de  línea.  
 
•  Ya  que  la  secuencia  de  escape  \n  significa  nueva  línea  o  salto  de  línea.    
•  NOTA:  no  olvide  que  las  secuencias  de  escape  son  constantes  de  un  solo  
caracter  por  lo  que  deben  estar  entre  ‘  ‘  cuando  se  usen  por  individual  
como  se  uFliza  cualquier  otro  carácter:  
char  caracter  =  ‘  \n’;    
3.12.2.  Entrada    
 Entrada  de  datos  con  función  scanf()  
•  La  entrada  de  datos  a  un  programa  puede  
tener  diversas  fuentes,  teclado,  archivos  en  
disco.    
•  La  entrada  que  consideramos  ahora  es  a  
través  del  teclado,  asociado  al  archivo  
estándar  de  entrada  stdin.    
•  La  función  mas  uFlizada,  por  su  versaFlidad,  
para  entrada  con  formato  es  scanf  (  )  .    
 Función  scanf()  
•  El  archivo  de  cabecera  stdio  .h  de  la  biblioteca  de  C  
proporciona  la  definición  (el  protoFpo)  de  scanf  (  )  ,  
así  como  de  otras  funciones  de  entrada  o  de  salida.    
•  Sintaxis:  
scanf(“cadena-­‐de-­‐control”,  varl,  var2,  .  .  .  );  
 
cadena-­‐de-­‐control  conFene  los  Fpos  de  los  datos  y  si  se  
desea  su  anchura.    
var  l  ,  var2  .  .  .  variables  del  Fpo  de  los  códigos  de  
control.    
 
 Códigos  de  control  
•  Los  códigos  de  control  más  comunes  son  los  
ya  indicados  en  la  salida.  Se  pueden  añadir,  
como  sufijo  del  código,  ciertos  modificadores  
como  I  o  L.    
•  El  significado  es  «largo»,  aplicado  a  float  (%If)  
indica  Fpo  double  y  aplicado  a  int  (%Id)  indica  
entero  largo.    
 Ejemplos    
•  int  n;  double  x;    
•  scanf  ("%d  %lf",&n,&x);    
 
•  La  entrada  Fene  que  ser  de  la  forma:    
 134              -­‐1.4E-­‐4    
 Operador  de  dirección  &  
•  En  este  caso  la  función  scanf()  devuelve  n=134  
x = -­‐ 1 . 4 E -­‐ 4   ( e n   d o b l e   p r e c i s i ó n ) .   L o s  
argumentos  varl  ,  var2...  de  la  función  scanf  ()  
se   pasan   por   modo   dirección   o   referencia  
pues  van  a  ser  modificados  por  la  función  para  
devolver  los  datos.    
•  Por  ello  necesitan  el  operador  de  dirección,  el  
prefijo  &.    
 
 Observación    
•  Un  error  frecuente  se  produce  al  escribir,  por  
ejemplo,    
 double  x;  
 scanf("%lf",x;)    
 en  vez  de  :  
 scanf  ("%lf",&x;)    

 
 Operador  de  dirección  &  
•  Las   variables   que   se   pasan   a   scanf()   se   transmiten  
por   referencia   para   poder   ser   modificadas   y  
transmiFr   los   datos   de   entrada,   para   ello   se   hacen  
preceder  del  operador  unario  de  dirección  &  .    
•  Ejemplos:    
 prinp("introduzca  vl  y  v2:”)  ;  
 scanf("%d  %f",&v1,&v2);  /*lectura  valores  vl  y  v2  *  /    
   
 Ejemplos    
 prinp("Precio  de  venta  al  público");    
 scanf  ("%f",&precio_venta);    
 
 prinp  ("Base  y  altura:  "  )  ;    
 scanf  ("%f  %f",&b,&h);  
 
•  La   función   scanf()   termina   cuando   ha   captado   tantos  
datos  como  códigos  de  control  se  han  especificado,  o  
cuando  un  dato  no  coincide  con  el  código  de  control  
especificado.    
 Ejemplo  3.5  
•  ¿Cuál  es  la  salida  del  siguiente  programa,  si  se  
introducen  por  teclado  las  letras  L  y  J?    
#include  <stdio.h>    
int  main()    
{    
char  primera,  ulFma;  
prinp(“Introduzca  su  primera  y  ulFma  inicial:");    
scanf("%c%c",  &primera,&ulFma);    
prinp("Hola,%c  .  %c  .\n",primera,ulFma)    
return  0;    
}  
 
Entrada  y  salida  con  cadenas  
  
3.12.3.  Salida  de  cadenas  de  caracteres    
 
•  Con  la  función  prinp(  )  se  puede  dar  salida  a  cualquier  
dato,  asociándolo  el  código  que  le  corresponde.  En  
parFcular,  para  dar  salida  a  una  cadena  de  caracteres  
se  uFliza  el  código  %s.  Así:  
char  cad[  ]  =  ”Hola";    
prin\  ("%s\n”,  cad);    
•  Para  salida  de  cadenas,  la  biblioteca  C  proporciona  la  
función  específica  puts()  .  Tiene  un  solo  argumento,  
que  es  una  cadena  de  caracteres.  Escribe  la  cadena  en  
la  salida  estándar  (pantalla)  y  añade  el  fin  de  línea.  Así:    
puts  (cad);  
muestra  en  pantalla  lo  mismo  que  prinp("%s\n”,  cad);    
  
3.12.4.  Entrada  de  cadenas  de  caracteres    
 
•  La  entrada  de  una  cadena  de  caracteres  se  
hace  con  la  función  más  general  scanf().  Por  
ejemplo:    
 char  nombre[51]  ;    
 prinp  (“Nombre  del  atleta:  “  );  
 scanf  (“%s”,nombre);  /*no  ocupa  &  por  ser    
 arreglo  */    
 prinp(“Nombre  introducido:  %s”,  nombre);    
•  La  entrada  del  nombre  podría  ser  :  

Luis  Joyanes  
 
•  La  salida  producida  sería:    
 
Nombre  introducido:  Luis  
 
•  scanf()   con   el   código   %s   capta   palabras,   el   criterio   de   terminación   es   el  
encontrarse  un  blanco,  o  bien,  fin  de  línea.    
•  También  comentar  que  nombre  no  Fene  que  ir  precedido  del  operador  de  
dirección  &.      
•  En  C  el  idenFficador  de  un  array,  nombre  lo  es,  Fene  la  dirección  del  array,  
por  lo  que  en  scanf  ()  se  transmite  la  dirección  del  array  nombre.  
 
   
 Función  de  entrada  gets()  
•  La  biblioteca  de  C  Fene  una  función  específica  
para  captar  una  cadena  de  caracteres,  la  función  
gets  (  )  .    
•  Capta  del  disposiFvo  estándar  de  entrada  una  
cadena  de  caracteres,  termina  la  captación  con  
un  retorno  de  carro.  El  siguiente  ejemplo  
muestra  cómo  captar  una  línea  de  como  máximo  
80  caracteres:  
   char  linea[81]  ;    
   puts("Nombre  y  dirección");  
     gets  (linea);    
•  La  función  gets()  Fene  un  solo  argumento,  una  
variable  Fpo  cadena.  Capta  la  cadena  de  entrada  
y  la  devuelve  en  la  variable  pasada  como  
argumento.    
gets(variabeCadena);    
 
•  Tanto  con  scanf()  como  con  gets()  ,  el  programa  
inserta  al  final  de  la  cadena  el  carácter  que  indica  
fin  de  cadena,  el  carácter  nulo  \0.    
•  Siempre  hay  que  definir  las  cadenas  con  un  
espacio  más  del  previsto  como  máxima  longitud  
para  el  carácter  fin  de  cadena.    
  
CAPíTULO  5    
 
Estructuras  de  selección:    
sentencias  if  y  switch  
 
 Introducción    
•  Los   programas   definidos   hasta   este   punto   se  
ejecutan   de   modo   secuencial,   es   decir,   una  
sentencia  después  de  otra.    
•  La   ejecución   comienza   con   la   primera   sentencia  
de  la  función  y  prosigue  hasta  la  úlFma  sentencia,  
cada  una  de  las  cuales  se  ejecuta  una  sola  vez.  
•  Esta   forma   de   programación   es   adecuada   para  
resolver   problemas   sencillos.   Sin   embargo,   para  
la   resolución   de   problemas   de   Fpo   general   se  
necesita  la  capacidad  de  controlar  cuáles  son  las  
sentencias  que  se  ejecutan,  en  qué  momentos.    
 
•  Las  estructuras  o  construcciones  de  control  controlan  la  
secuencia  o  flujo  de  ejecución  de  las  sentencias.    
•  Las   estructuras   de   control   se   dividen   en   tres   grandes  
categorías  en  función  del  flujo  de  ejecución:  
–  secuencia,    
–  selección      
–  repe>ción.    
•  Este   capítulo   considera   las   estructuras   selec>vas   o  
condicionales:   sentencias   if   y   switch   que   controlan   si  
una   sentencia   o   lista   de   sentencias   se   ejecutan   en  
función  del  cumplimiento  o  no  de  una  condición.  
  
5.2.  LA  SENTENCIA  if  
 
•  En  C,  la  estructura  de  control  de  selección  
principal  es  una  sentencia  if.    
•  La  sentencia  if  Fene  dos  alternaFvas  o  
formatos  posibles.    
•  If  simple:    
If  (condición)  
                 sentencia;        ó  
     {sentencias}  
•  condición   es   una   expresión   lógica   que  
determina  SI  la  sentencia  se  ha  de  ejecutar.    
•  sentencia   es   cualquier   sentencia   ejecutable,  
que  se  ejecutará  sólo  si  la  condición  toma  un  
valor  disFnto  de  cero  (verdadero).    
•  Su  diagrama  de  flujo  es  :  
 
condición  

Sentencia(s)  
  
Ejemplo  5.1    
/*Prueba  de  divisibilidad    
 
Fecha  */  
#include  <stdio.h>  
 int  main(  )  
{  
 int  n,  d;  
 prinp(  "Introduzca  dos  enteros:")  ;    
 scanf("%d%d",&n,&d);  
 
 if  (n  %  d  ==  0)    
   prinp  (  "  %d  es  divisible  por  %d\n",n,d);    
 
 puts(“\n\n\n\n\nOprima  cualquier  tecla  para  terminar:”);  
 return  0;    
}  
 Salida    
Introduzca  dos  enteros:  36  4    
36  es  divisible  por  4    

Oprima  cualquier  tecla  para  terminar:_