Ip4 PDF

Tema 4 Lenguaje de programacin.
Tema 4.
4. Lenguaje de Programacin.

4.1 Desarrollo de Programas.

4.1.1 Ingeniera y anlisis del sistema.
Debido a que el software es siempre parte de un sistema mayor, el trabajo comienza estableciendo los
requerimientos de todos los elementos del sistema y luego asignado algn subconjunto de estos
requerimientos al software.
El ingeniero de software debe comprender el dominio de la informacin del software, as como la
funcin, rendimiento e interfaces requeridas. Los requerimientos tanto del sistema como del software
se documentan y revisan con el cliente.

4.1.2 Diseo.
El proceso de diseo traduce los requerimientos en una representacin del software que pueda ser
establecida de forma que obtenga la calidad requerida antes de que comience la codificacin.
Como los requerimientos, el diseo se documenta y forma parte de la configuracin del software.
4.1.3 Codificacin.
El diseo debe traducirse en una forma legible para la mquina. Si el diseo se realiza de manera
detallada, la codificacin puede realizarse mecnicamente.
4.1.4 Prueba.
La prueba se enfoca sobre la lgica interna del software, asegurando que todas las sentencias se han
probado, y sobre las funciones externas para asegurar que la entrada definida producir los resultados
que realmente se requieren.
4.1.5 Mantenimiento.
El software sufrir indudablemente cambios despus de que se entregue al cliente, debido a que se han
encontrado errores, o debido a que el cliente requiere aumentos funcionales o del rendimiento.
El ciclo de vida clsico es el ms viejo y ms usado paradigma en la ingeniera del software. Sin
embargo con el paso de unos cuantos aos, se han producido crticas que cuestionan su aplicabilidad.
Entre los problemas que se presentan algunas veces se encuentran:
1. Los proyectos reales raramente siguen el flujo secuencial que propone el modelo.
2. Normalmente es difcil para el cliente establecer explcitamente al principio todos los
requerimientos.
3. El cliente debe tener paciencia. Una versin funcionando del programa no estar disponible hasta
las etapas finales del desarrollo del proyecto.
M. en C. Rafaela Blanca Silva Lpez
Pgina 1
Curso SAI - Introduccin a la Programacin

Cada uno de los problemas es real sin embargo el ciclo de vida clsico permanece como el modelo
procedimental ms ampliamente utilizado.
4.1.6 Documentacin.
La documentacin juega un papel primordial en el desarrollo y ciclo de vida del software.

4.2 Lenguaje de Programacin C.

4.2.1 Etapas de elaboracin de un programa en C.

1. Crear el archivo fuente con un editor de texto.
2. Compilacin. Esta se divide en varias etapas la primera se conoce como preprocesamiento.
3. Revisin de la sintaxis y semntica del cdigo.
4. Traduccin a cdigo en lenguaje ensamblador.
5. Generacin del cdigo en lenguaje de maquina.
6. Etapa de enlazamiento. En esta se da la generacin del programa ejecutable.

Una vez que haz creado l (los) archivo(s) fuente usando un editor de texto, ste(os) debe(n) ser
compilado(s) y enlazados antes de que puedas ejecutar el programa.
El compilador realiza varios pasos de manipulacin sobre el cdigo fuente para as traducir el cdigo
de lenguaje C a cdigo propio de la computadora. El primer paso de compilacin, consiste en invocar
al preprocesador de C. El preprocesador reconoce proposiciones especiales llamadas directivas de
preprocesamiento que pueden estar intercaladas dentro del cdigo fuente. El resto de las etapas de
compilacin, incluyen la verificacin del cdigo fuente para asegurar que ste de acuerdo con la
sintaxis y semntica del lenguaje C, la traduccin a cdigo ensamblador, la traduccin a cdigo
binario o lenguaje mquina, y por ultimo el enlazamiento. El cdigo binario obtenido es llamado
cdigo objeto, el cual es escrito a otro archivo. Las primeras etapas de compilacin se representan
esquemticamente en la figura 1.

Figura 1. Primeras Etapas de compilacin.

Despus de que el programa se ha traducido a cdigo binario est listo para ser ligado. El propsito de
la fase de enlazamiento es traducir el programa a un cdigo que pueda ser ejecutado por la mquina.
Pgina 2 .
El enlazador toma el archivo objeto y establece las referencias necesarias para ubicar funciones
externas y bibliotecas. De esta manera se crea el cdigo ejecutable del programa, el cual es
almacenado en otro archivo.
Una vez enlazado el programa puede ejecutarse. La etapa de enlazamiento se representa
esquemticamente en la figura 2.

Figura 2. Ultima Etapa de Compilacin. Etapa de ligado.

4.3 Estructura de un programa en C.

Un programa desarrollado en lenguaje C est constituido por uno o ms archivos fuente. Un archivo
fuente es un archivo que contiene una o ms funciones y, posiblemente, referencias a uno o ms
archivos header.
Una de las funciones que componen el programa es nombrada como main. La ejecucin del programa
inicia en esta funcin. Las funciones invocadas en main deben ser descritas en los archivos fuente o en
la biblioteca estndar de C.
Un archivo header es un archivo que es proporcionado por el sistema o creado por el programador. Si
ste es un archivo ASCII, contiene declaraciones y definiciones de funciones y variables.
La figura 3 muestra esquemticamente la composicin de un programa desarrollado en C.

Programa
Figura 3. Esquema de la composicin de un programa en C.

Las funciones realizan tareas especficas del programa. La estructura general de una funcin es:
Pgina 3

tipo nombre_de_la_funcion(lista_de_parametros)
{
cuerpo de la funcin
}.
La funcin est constituida de proposiciones. Existen muchos tipos de proposiciones. Una proposicin
es cualquier expresin vlida la cual es seguida inmediatamente de un punto y coma. Por ejemplo:
c = 22;
printf(Control Escolar.\n);
return;

Una proposicin puede ser simplemente un punto y coma:
;
O una proposicin compuesta, formada de otras proposiciones encerradas entre llaves:
{
printf(Fin de programa.\n);
return (0);
}

Una expresin est compuesta por operadores y operandos en una estructura sintcticamente correcta.
Ejemplos de expresiones son:
c = a*b;
y = y+1;
res = (2*c)*(5+a)/b;

4.4 Preprocesador:

El preprocesador de C es un programa que es llamado durante el primer paso de compilacin. El
preprocesador reconoce las directivas del preprocesador que estn escritas en el cdigo fuente. Las
directivas inician con un signo #. Las directivas son utilizadas para indicar que se inserte el contenido
de los archivos header, definir nombres simblicos para constantes del programa, definir macros, etc.
Las dos directivas del preprocesador ms comunes son #include y #define.
La directiva #include es empleada para indicar que se inserte un archivo header dentro del cdigo
fuente. Su sintaxis es:
#include <archivo_header>

Cuando el preprocesador encuentra el signo #, ste reconoce que la proposicin es una directiva al
preprocesador, localiza el archivo header, y lo copia en el archivo fuente antes de llamar al
Pgina 4 .
compilador. Los signos < y > indican al preprocesador que el header es un archivo de sistema, el cual
se localiza en un directorio especfico del sistema. En el sistema operativo UNIX, el directorio de
sistema es /usr/include/. Si el header se encuentra encerrado entre comillas, el archivo se busca en el
directorio de trabajo, al menos que se incluya una trayectoria en el nombre del archivo. Por lo regular
la ultima opcin se emplea con archivos que son escritos por el programador, o con libreras que se
compren para un propsito especifico.
Como ejemplo:
#include <stdio.h>
#include <string.h>
int main(void)
{
char cadena[80]
strcpy(cad, Cadena de caracteres.);
printf(%s, cadena);
return (0);
}

NOTA. Es importante indentar un programa para facilitar su lectura e incrementar su claridad.

4.4.1 Ejemplo de un programa en C.

/***************************************************
* Este programa imprime un mensaje de bienvenida. *
***************************************************/
#include <stdio.h>
int main(void)
{
printf("Bienvenido al mundo de C. \n");
return(0);
}

4.4.2 Descripcin del programa.

Comentarios. (/*...*/)
Todo lo que escribas entre /* y */ se consideran como comentarios, y son ignorados por el compilador.

stdio.h
Pgina 5

Es un archivo header que proporciona al compilador la definicin de la funcin printf().
int main(void)
Es el nombre de la funcin principal. Los parntesis indican que main es el nombre de una funcin.
{ } Indican el principio y final de la funcin main.
printf:
Es una funcin que despliega en pantalla el mensaje indicado. En el ejemplo, la cadena de caracteres
"Bienvenido al mundo de C. Cmo estas? \n" es el argumento de la funcin. Los ltimos dos
caracteres ("\" y "n") forman el carcter salto de lnea. Esto produce que el cursor se mueva a la
siguiente lnea.

4.5 Operadores y operandos.

Los operandos son aquellos elementos de un programa sobre los cuales se puede aplicar algn
operador.
Los operandos son de 2 tipos: Constantes y Variables.
Las constantes son aquellos elementos de un programa que no cambian su valor durante la ejecucin.
En cambio las variables si son susceptibles de modificarse.
Los operandos tienen los siguientes atributos:
Nombre. El nombre de un operando en C se conoce como identificador.
Los identificadores en C son alfanumricos

y se incluye el carcter _,

el cual es interpretado
como una letra.
De acuerdo al estndar ANSI, un identificador puede estar compuesto a lo mas por 32
caracteres.
En C se hace distincin entre mayscula y minsculas. Por esta razn, los identificadores
siguientes son distintos: (HOLA, hola, Hola, ...).
No deben ser palabras reservadas.

Tipo. En C existen 5 tipos bsicos de datos. En la tabla 1 se resumen los nombres, el rango de valores
y el tamao en bytes que ocupa cada uno.
Tabla 1 Tipos de datos bsicos en C
Tipo Rango Tamao en bytes
char -128,127 1
int -32768,32767
-2147483648,2147483647
2
4
float 1.1E-38, 3.4E38 4
double 2.2E-308, 1.7E308 8
void - 0
Pgina 6 .

El tipo char es para manejar los caracteres. En C los caracteres se manejan mediante el valor ASCII
de los mismos. Dado que en el ASCII existen 256 caracteres podras pensar que l char varia de 0 a
255. En la tabla 1 puedes observar que varia de -128 a 127.
El tipo int es para manejar los datos de tipo entero. Este tipo de dato ocupa 2 o 4 bytes en memoria
dependiendo del hardware. Por ejemplo en una PC solo ocupa 2 bytes. En una maquina multiusuario,
ocupa 4.
El tipo float es para manejar nmeros reales o de punto flotante. En la tabla damos los valores
aproximados del valor ms pequeo y el ms grande que puede ocupar. Tienen por lo general solo 7
cifras de precisin.
El tipo double son nmeros flotantes de precisin doble, con aproximadamente 15 cifras de precisin.
El tipo void no ocupa memoria y por lo tanto no tiene rango de valores.
Como no es suficiente en la practica con estos tipos de datos, lenguaje C proporciona lo que se
denomina modificadores de tipo, estos alteran el tamao o el rango de valores, y son:
unsigned: Hace que el tipo de dato no tenga valores negativos.
signed: Realza el hecho de que el tipo de dato tiene signo.
short: Reduce el tamao.
long: aumenta el tamao.
En la tabla 2 se muestra el resultado de aplicar los modificadores a los tipos bsicos.

Tabla 2 Tipos de datos bsicos modificados en C
Tipo Rango Tamao en bytes
unsigned char 0,255 1
unsigned int 0,65535
0,4294967295
2
4
short int -32768,32767 2
long int -2147483648,2147483647 4
unsigned short int 0,65535 2
unsigned long int 0,4294967295 4

Como puedes apreciar unsigned char tiene como efecto que los valores negativos se pasen a los
positivos, por esta razn, ahora si se maneja todo el ASCII. No es licito aplicarle short o long.
En el tipo int se ve un efecto similar al del tipo char con el modificador unsigned. Los valores
negativos se suman a los positivos.
Los modificadores short y long afectan de acuerdo al tamao que ocupe el int en la maquina que se
trabaje. En maquinas de 2 bytes, el short no tiene efecto. El long aumenta el tamao a 4 bytes. En
maquinas de 4 bytes el long no tiene efecto. El short reduce el tamao a 2 bytes. El estndar ANSI
garantiza que short ocupa siempre menos espacio que el long.
El efecto del modificador signed no se nota porque deja el tipo de dato como esta.
Pgina 7

A los datos de tipo flotante es ilegal aplicarles el modificador unsigned.
Si aplicamos long a float se obtiene double. No es licito aplicarle short.
Si aplicamos short a double obtenemos float. Si es legal aplicarle long a double, pero el resultado
depende tanto del compilador como del hardware que se utilice.
No es licito aplicarle algn modificador a void.
Por default si solo se aplica el modificador de tipo, se supone que se aplica a datos de tipo int, por esa
razn long es equivalente a long int, short a short int, etc.

4.5.1 Valor
Los valores que pueden manejarse en C, dependen del tipo de dato.

4.5.1.1 char
Como ya se menciona l char puede manejarse con su valor en cdigo ASCII. Tambin puede
manejarse propiamente como un carcter. Para ello el carcter deseado se encierra entre apstrofos,
por ejemplo: a, b, #, &
Existen una serie de caracteres que no estn en el teclado y que tienen un significado especial. Por
ejemplo el carcter que representa al ENTER. Estos caracteres invisibles en C se representan con lo
que se conoce como secuencias de escape. Las secuencias de escape inician con el carcter \. Por
ejemplo tenemos:
\n Salto de lnea
\r ENTER
\a Campana.
4.5.1.2 int
Los valores que pueden tomar los enteros son variados, ya que hay que considerar los modificadores
de tipo, adems del hecho que C maneja enteros no solo en base 10.
Los enteros simples son nmeros sin punto decimal, por ejemplo: 123, -88,1985
Si consideramos los enteros sin signo, estos se representan aadiendo una u al final: 123u, 88U, 1985
Los enteros por default son signed.
Los enteros cortos terminan con h: 123h, 88H, 1985h
Los enteros largos terminan con l: 123l, 88L, 1985l
Adems de estos valores enteros C maneja enteros en base 8 y base 16.
Los valores enteros octales empiezan con 0:010, 0123, 07
Los valores enteros hexadecimal empiezan con 0x: 0x10, 0xA, 0x123
4.5.1.3 float
Los valores constantes flotantes poseen una parte entera y una decimal, se escriben con una letra f al
final: 3.14f, 2.71F
Tambin se maneja la notacin cientfica: 6.02217e23f, 6.67E-11F
4.5.1.4 double
Pgina 8 .
Por default una constante con punto decimal es de tipo doble: 3.14, 2.71, 6.02217e23, 6.67E-11
Si al final se aade una l o L, el valor es de tipo long double: 3.14l, 2.71L, 6.02217e23L, 6.67E-11L
4.5.1.4.1 Cadena
Las cadenas se utilizan ampliamente para el manejo de la informacin, se define como un conjunto de
caracteres. C no tiene el tipo de dato cadena, sin embargo si tiene valores constantes de tipo cadena.
Estas se encierran entre comillas: Hola, Que tal\n
Como puedes observar se pueden incluir secuencias de escape si es necesario.

4.5.2 Constantes

Como definimos anteriormente una constante es un valor que no cambia durante la ejecucin de un
programa.

En C existen varias formas para declarar constantes.
4.5.2.1 Const
La sintaxis de declaracin es:
const tipo cte = valor;
Por ejemplo:
const int maximo = 100;
const float pi = 3.1415926f;
Si el tipo se omite por default la constante es de tipo int.
const minimo = 1;
Cualquier intento de modificar el valor originara un error.

4.5.2.2 #define
La sintaxis de esta directiva tiene la forma siguiente:
#define NOMBRE texto_de_reemplazo
La directiva #define es usada para asignar nombres simblicos a constantes del sistema. NOMBRE
tiene la misma forma que un nombre de variable; el texto_de_reemplazo es arbitrario. Normalmente el
texto de reemplazo es el resto de la lnea, pero una definicin larga puede continuarse en varias lneas
mediante la colocacin de un \ al final de cada lnea a continuarse. El alcance de un nombre
definido con la directiva # define es desde el punto de definicin hasta el final del archivo fuente
siendo compilado.
Por ejemplo:
#define VERDADERO 1
#define FALSO 0
Estas proposiciones asignan el nombre simblico VERDADERO al valor constante 1, y el nombre
simblico FALSO al valor constante 0. Esto significa que en cualquier lugar, a lo largo del cdigo
Pgina 9

fuente, donde se encuentre escrita la macro, automticamente el preprocesador remplazara la macro
con el valor constante correspondiente a ese nombre.

4.5.2.3 Enumeraciones

Existen casos donde vamos a definir una serie de constantes de tal forma que a cada constante le
corresponde un valor entero. Tal es el caso de un men, donde podramos definir:

#define ENTRADA 0
#define PROCESO 1
#define SALIDA 2

En un cdigo el programador puede sustituir los valores por las constantes correspondientes.
1

Un problema que se presenta es cuando introducimos opciones nuevas la men, por ejemplo
validacin y reporte:

#define ENTRADA 0
#define VALIDACIN 1
#define PROCESO 2
#define REPORTE 3
#define SALIDA 4

Es necesario que modifiquemos el valor de las constantes. Esto puede ser muy tedioso.
Las enumeraciones son una alternativa en este caso. Una enumeracin es un mapeo de un conjunto de
identificadores a un conjunto de valores enteros. Su sintaxis es:

enum nombre{ID1,ID2,...,IDn};

Los identificadores por convencin se escriben con maysculas. El primero vale 0, el segundo 1 y as
sucesivamente. Considerando el ejemplo anterior tenemos:

enum menu{ENTRADA,PROCESO,SALIDA};

La ventaja de usar una enumeracin se ve al aadir otras opciones:

1
Tambin podemos usar la palabra reservada const, para definir las constantes.
Pgina 10 .
enum menu{ENTRADA,VALIDACION,PROCESO,REPORTE,SALIDA};

Automticamente el compilador renumera las constantes.
Si deseamos que no empiecen en 0, podemos indicarlo explcitamente:

enum menu{ENTRADA=1,PROCESO,SALIDA};

En este caso la numeracin inicia en 1.

4.5.3 Variables

Para declarar variables la sintaxis es:
tipo var1,var2,...,varn;
Por ejemplo:

int max, min;
float x;
double y;
unsigned char c;
long extension;
Una variable no tiene un valor inicial. En C es posible inicializar las variables en su declaracin:
int max=100,min;
float x=3.4f;
double y=6.023e23;
unsigned char c=\n;
long extension=65l;
En el primer caso solo s inicializa la variable max.

4.5.4 Declaracin de tipos de datos nuevos.

En C es posible declarar tipos de datos nuevos. La sintaxis para esto es:
typedef definicin nombre;
Donde definicin es la definicin del tipo de dato y nombre el identificador del nuevo tipo de dato.
Por ejemplo si no te gusta tener que declarar las variables reales con float, puedes crear el tipo de dato
real:
typedef float real;
Pgina 11

Ahora las variable reales puedes declararlas:
real x,y;

4.6 Operadores.

Los operadores se clasifican en:
Aritmticos
Asignacin
Relacinales
Lgicos
Miscelneos

4.6.1 Operadores Aritmticos

Los operadores aritmticos son: +,*, /, %, ++, ( ).
Los primeros cuatro son los clsicos operadores bsicos. Si los operandos son enteros dan resultados
de tipo entero. En la divisin hay un problema. Si los operandos son enteros la divisin tambin es
entera, esto es, se calcula el cociente truncado, solo se regresa la parte entera de la divisin. Por
ejemplo:
5 / 2 es 2, no 2.5
Si deseamos la divisin con punto decimal al menos uno de los operandos debe de ser float o double:
5 / 2. es 2.5
Si mezclamos tipos de datos el resultado es del tipo de dato mas alto, esto es, que ocupe mas memoria.
Curiosamente los operadores pueden aplicarse a datos de tipo char. En este caso se trabaja con el valor
ASCII de los caracteres.
El operador de modulo %, el cual solo se aplica a operandos enteros, regresa el residuo de la divisin.
Por ejemplo:
10 % 3 es 1
20 % 7 es 6
Los operadores de mas y menos unario se refieren a lo siguiente:
+x+1
-x+1
Las expresiones anteriores son validas, sin embargo, no son ni sumas ni restas. En la primera, el
primer signo de + es el operador mas unario, su efecto es multiplicar por uno. En la segunda, el signo
de - es el menos unario, su efecto es multiplicar por -1.
Los ltimos operadores incremento y decremento solo incrementan o decrementan en 1. Solo es legal
aplicarlos a variables. Por ejemplo:
int x=1,y=2;
Pgina 12 .
x++;
y--;
La x vale 2 y la y vale 1.
Estos operadores tienen una jerarqua, es decir, algunos se realizan antes que otros. La jerarqua de
menor a mayor es como estn presentados. La jerarqua puede romperse usando parntesis.

4.6.2 Operadores de asignacin

El operador de asignacin se emplea para asignar valores a las variables, en C es =. Por ejemplo:
x=y+1;
Este operador tiene un efecto curioso con los operadores ++ y --. No es igual asignar los operadores
prefijos que postfijos. Observa el siguiente ejemplo:
int x=1,y;
int w=1,z;
y=x++;
z=++w;
En el primer caso la x vale 2 y la w tambin. La y vale 1 y la z vale 2. Esto se debe a que en la primera
asignacin se asigna el valor de x y despus se aplica el operador. En la segunda, primero se aplica el
operador y luego se asigna.

4.6.3 Operadores relacionales.

Los operadores relacionales son: >, <, >=, <=, ==, !=.
Estos operadores deberan de regresar un resultado de tipo boleano. Pero en C no existe el tipo
boleano. En vez de manejarse los valores bolanos cierto y falso para C todos aquello que sea falso
tiene un valor de 0, y todo aquello que sea verdadero tiene un valor distinto de 0, generalmente 1.
Entonces estos operadores regresan 0 o 1. Por ejemplo:
2 < 4 es 1
2 < 1 es 0

4.6.4 Operadores lgicos.

Estos operadores son: && (AND), || (OR), ! (NOT).
Se emplean para conectar 2 expresiones de relacin. Regresan 0 o 1.
El && es cierto si y solo si ambos operandos son ciertos. Por ejemplo:
2 < 4 && 4 > 1 es 1
2 < -4 && 4 > 1 es 0
El || es falso si y solo si ambos operandos son falsos. Por ejemplo:
Pgina 13

2 < 4 || 4 > 1 es 1
-2 < -4 || -4 > 1 es 0
El ! Invierte el valor lgico. Si l operando es 0, regresa 1. Si l operando es distinto a 0, regresa 0.
Por ejemplo:
! (2>4) es 1
! (-2>-4) es 0

4.6.5 Operadores miscelneos

sizeof
El operador sizeof se aplica a tipo de datos o a variables y regresa el tamao en bytes que ocupa l
operando. Por ejemplo:
sizeof (char) es 1
sizeof (int) es 2 o 4
float x;
sizeof (x) es 4

4.7 Estructuras de control

Las estructuras de control que maneja C son:
4.7.1 Selectivas.
Seleccionan entre uno mas caminos de accin. Pueden ser:
Simple
Doble
Mltiple

4.7.1.1 Simple.
Su sintaxis es:
if (condicin)
Proposicin;
Si la condicin es cierta se ejecuta la proposicin y se continua con la siguiente instruccin. Si es falsa
se continua con la siguiente instruccin. Ejemplo:
if (x>1)
y++;
Si x es mayor a 1 la y se incrementa. En caso contrario no.

Pgina 14 .
4.7.1.2 Doble.
La sintaxis es:
if (condicin)
prop1;
else
prop2;
Si la condicin es cierta se ejecuta la prop1. Si es falsa se ejecuta la prop2. Ejemplo:
if (x!=1)
y++;
else
y--;
Si x no es 1, la y se incrementa. Si la x es 1 la y s decrementa.

4.7.1.3 Mltiple
La sintaxis es:
if (condicin 1)
proposicin 1
else if (condicin 2)
proposicin 2
else if (condicin 3)
proposicin 3

else if (condicin n)
proposicin n
else
proposicin x
Se prueba la condicin 1 si es cierta se realiza la proposicin 1. Si es falsa se pregunta por la
condicin 2. Si es cierta se realiza la proposicin 2. Si es falsa se pregunta por la condicin 3. Si es
cierta se realiza la proposicin 3. Si es falsa se pregunta sucesivamente por las restantes. Si alguna es
cierta se realiza y si es falsa se pregunta por las dems. Si todas son falsa se realiza la proposicin x.
Si ms de una es cierta se realiza la primera que se encuentre. El else es opcional. Si no se incluye y
todas las condiciones son falsas se realiza nada.
Se tiene otra estructura de control para la seleccin mltiple. Esta se emplea cuando se implementa un
men. Al realizar un programa es frecuente que se muestre al usuario las opciones que tiene para
ejecutar en un determinado programa. El tiene que seleccionar entre una serie de opciones. Estas a su
vez estn numeradas consecutivamente o en su defecto identificadas con una letra. En cualquier caso
Pgina 15

las condiciones que se tiene que probar para ver que opcin se va a ejecutarse son sobre un conjunto
finito de valores. En estas circunstancias se puede usar la instruccin switch.

switch (expresin) {
case val 1:
proposicin 1
break;
case val 2:
proposicin 2
break;
case val 3:
proposicin 3
break;

case val n:
proposicin n
break;
default:
proposicin x
break;
}
La expresin debe de regresar un conjunto finito de valores, por ejemplo los nmeros del 1 al 10 o las
letras de la A a la Z. Se verifica el valor regresado por la expresin con cada uno de los valores
indicados en los cases. A la primera coincidencia se realiza esa proposicin. Si coincide con ms de
uno se realiza la primera en hallarse. Si no se encuentra el valor se realiza lo que esta en default, la
proposicin x. Anlogamente al caso del if mltiple el default es opcional. Si no se incluye y no halla
ninguna coincidencia del valor regresado por la expresin se hace nada.
El break no es forzoso, pero si no se incluyen, al hallarse una coincidencia, se ejecutan las
proposiciones hasta el final de la instruccin, es decir, si por ejemplo, se halla el val 2, se ejecutan
todas las proposiciones hasta el final del switch.

4.7.2 Repetitivas

Las estructuras de control repetitivas, tambin llamadas ciclos, sirven para repetir una serie de
acciones hasta que se cumpla alguna condicin. Pueden ser:
while
Pgina 16 .
do while
for

4.7.2.1 while
Sintaxis:
while (condicin)
proposicin;
Mientras la condicin sea cierta se realiza la proposicin. Cuando sea falsa el ciclo termina. Por
ejemplo:
while (x<=10)
x++;

4.7.2.2 do while
La sintaxis es:
do
proposicin
while (condicin);
Primero se realiza la proposicin y despus se pregunta por la condicin. Si la condicin es falsa el
ciclo termina. Si es cierta se repite la proposicin hasta que la condicin sea falsa. Por ejemplo:
do
x--;
while (x>=10);

4.7.2.3 for
La sintaxis es:
for (inicializacin ;convergencia ;modificacin)
proposicin;
En la inicializacin se inicializa el valor de la variable con la que se va a controlar el ciclo. En la
convergencia se especifica la condicin que debe cumplirse para que se ejecute el ciclo. En la
modificacin se inicia como se debe de alterar el valor de la variable con la que se controla el ciclo.
Por ejemplo:
int i;
for(i=1;i<=10;i++)
printf(%i\n, i);
Este ciclo imprime los nmeros del 1 al 10.
El ciclo for de C es ms potente que el equivalente de otros lenguajes, ya que las expresiones con las
que se controla el ciclo son completamente generales. Por ejemplo:
Pgina 17

for(i=0;!(i%2) && i<=10;i++)
printf(%i\n, i);
Este ciclo imprime los pares menores o iguales a 10.
for(i=0,k=2;j!=5;z*=2)
En este ciclo s inicializan 2 variables, se pregunta por una tercera para controlar el ciclo y se
modifica otra.
Inclusive las expresiones son opcionales. Ejemplo:
for(;;);
El ciclo anterior es sintcticamente valido.

4.7.3 Miscelneas

Se emplean en el control de ciclos. Son:
4.7.3.1 break
La instruccin break termina la ejecucin de un ciclo. Ejemplo:
for(i=0;;i++)
if (i<=10)
printf(%i\n, i);
else
break;
Este ciclo imprime los nmeros del 1 al 10. Nota que se omite la condicin de convergencia. Cuando i
es 11 el ciclo termina.

4.7.3.2 continue
El continue termina la iteracin actual de un ciclo, es decir, nos saltamos a la siguiente iteracin.
Ejemplo:
for(i=0; i<=10;i++)
if (i==5)
continue;
printf(%i\n, i);
Este ciclo imprime los nmeros del 1 al 10 excepto el 5. Nota que se omite la condicin de
convergencia. Cuando i es 11 el ciclo termina.

4.8 Manejo de entrada y salida simple.

Pgina 18 .
En lenguaje C, las cadenas de caracteres se pueden desplegar en pantalla empleando la funcin
printf(). La sintaxis de esta funcin es:
int printf (formato, argumentos);
La cadena apuntada por formato se compone de dos tipos de elementos. En el primer tipo se
encuentran los caracteres que sern desplegados en pantalla. El segundo tipo contiene las rdenes de
formato que indican la forma en que sern desplegados los argumentos. Una orden de formato
comienza con un signo de % y le sigue el cdigo del formato. Debe existir el mismo nmero de
argumentos que de rdenes de formato. De este modo, los argumentos y las rdenes se asocian en el
orden expuesto. Si no hay suficientes argumentos que asociar a las rdenes de formato, la salida queda
indeterminada. Si hay mas argumentos que rdenes de formato, se descarta el resto de los argumentos.
En la siguiente tabla se muestran las rdenes de formato ms usadas.
Cdigo Formato
%c Carcter nico.
%d Enteros decimales con signo.
%i Enteros decimales con signo.
%e Notacin cientfica e minscula.
%f Coma flotante.
%o Octal sin signo.
%s Cadena de caracteres.
%u Enteros decimales sin signo.
%x Hexadecimal sin signo letras minsculas.
%p Apuntador.

Algunos ejemplos del uso de esta funcin se presentan a continuacin:
printf(Bienvenidos al mundo de C.);
Despliega el mensaje Bienvenidos al mundo de C.
printf(El numero es: %d, 10);
Despliega el mensaje El numero es: 10.
printf(%f es un nmero de coma flotante., 23.98);
Despliega el mensaje 23.98 es un nmero de coma flotante.
Esta funcin est definida por el estndar ANSI y requiere del archivo header stdio.h, para poder
ejecutarse.
De igual modo, para lectura de cadenas tenemos la funcin scanf(). La sintaxis de esta funcin es:
int scanf (formato, argumentos);
La cadena de control apuntada por formato se compone de tres tipos de elementos: especificadores de
formato, caracteres de espacio en blanco y caracteres que no sean espacios en blanco.
Los especificadores de formato de entrada estn precedidos por el signo % y le indican a scanf que
tipo de dato ser ledo. Los cdigos de formato se mostraron en la tabla correspondiente a la funcin
printf().
Pgina 19

La cadena de formato se lee de izquierda a derecha y los cdigos de formato se asocian en orden, con
los argumentos que se encuentran en la lista.
Un espacio en blanco en la cadena de formato, da lugar a que scanf() lea, pero no guarde.
Un carcter que no sea espacio en blanco hace que scanf() elimine este carcter, pero lea en los
cdigos de formato que se le indiquen.
Todas las variables usadas para recibir valores a travs de scanf() se deben pasar por sus direcciones.
Esto significa que todos los argumentos deben ser apuntadores a las variables donde se almacenarn
los datos ledos. Esto se especifica con el uso del carcter & precediendo al nombre de la variable.
En el caso de cadenas de caracteres, las cuales son arreglos de caracteres, no se requiere el uso del
carcter &, ya que con el solo nombre de la cadena se especifica la direccin del primer elemento del
arreglo.
Esta funcin delimita las cadenas con espacios y saltos de lnea. Por tal razn, solo la primera palabra
tecleada por el usuario es leda por scanf(). Esta funcin coloca en buffers todas las palabras
introducidas desde el teclado. Esto significa que si ms de una palabra es tecleada, scanf() tomar
automticamente la segunda palabra y la introducir en la siguiente llamada a scanf().
Algunos ejemplos del uso de esta funcin se presentan a continuacin:
scanf(%d, &numero);
Lee un entero que se almacenar en numero.
scanf(%s%f, cadena, &numero);
Lee una cadena de caracteres y un nmero de coma flotante.
scanf(%d:%d, hora, minuto);
Lee dos enteros y descarta los dos puntos.

Esta funcin est definida por el estndar ANSI y requiere del archivo header stdio.h, para poder
ejecutarse.
A continuacin se presenta un segmento de programa que utiliza las funciones:
char cadena[80];
printf (Introduce una cadena: );
scanf (%s, cadena);
printf (cadena = %s\n, cadena);
La ejecucin sera:
Introduce una cadena: Hola a todos.
cadena = Hola
Para scanf() la cadena termina al encontrar un espacio en blanco o el carcter de salto de lnea.
Otra funcin que tambin lee cadenas es gets. La sintaxis de esta funcin es:
int gets (char cadena);
La funcin de entrada gets, lee caracteres hasta que un carcter de salto de lnea o el carcter EOF son
encontrados. El carcter de salto de lnea es desechado y la cadena se termina con un carcter nulo.
La contraparte de la funcin gets es la funcin puts, cuya sintaxis es:
Pgina 20 .
int puts (char cadena);
Esta funcin escribe la cadena en pantalla, reemplazando el carcter nulo con un salto de lnea.
As, el segmento de programa anterior puede ser escrito de la siguiente manera:
char cadena[80];
printf (Introduce una cadena: );
gets (cadena);
printf (cadena = %s\n, cadena);
Pgina 21

4.9 ndice
Tema 4. ..........................................................................................................................................................................1
4. Lenguaje de Programacin......................................................................................................................1
4.1 Desarrollo de Programas. ______________________________________________ 1
4.1.1 Ingeniera y anlisis del sistema..............................................................................................................1
4.1.2 Diseo. ....................................................................................................................................................1
4.1.3 Codificacin. ...........................................................................................................................................1
4.1.4 Prueba. ....................................................................................................................................................1
4.1.5 Mantenimiento. .......................................................................................................................................1
4.1.6 Documentacin. ......................................................................................................................................2
4.2 Lenguaje de Programacin C. __________________________________________ 2
4.2.1 Etapas de elaboracin de un programa en C. ..........................................................................................2
4.3 Estructura de un programa en C. _______________________________________ 3
4.4 Preprocesador: ______________________________________________________ 4
4.4.1 Ejemplo de un programa en C.................................................................................................................5
4.4.2 Descripcin del programa. ......................................................................................................................5
4.5 Operadores y operandos. ______________________________________________ 6
4.5.1 Valor .......................................................................................................................................................8
4.5.1.1 char ....................................................................................................................................................8
4.5.1.2 int .......................................................................................................................................................8
4.5.1.3 float ....................................................................................................................................................8
4.5.1.4 double ................................................................................................................................................8
4.5.2 Constantes ...............................................................................................................................................9
4.5.2.1 Const ..................................................................................................................................................9
4.5.2.2 #define ...............................................................................................................................................9
4.5.2.3 Enumeraciones.................................................................................................................................10
4.5.3 Variables ...............................................................................................................................................11
4.5.4 Declaracin de tipos de datos nuevos. ..................................................................................................11
4.6 Operadores. ________________________________________________________ 12
4.6.1 Operadores Aritmticos ........................................................................................................................12
4.6.2 Operadores de asignacin .....................................................................................................................13
4.6.3 Operadores relacionales. ......................................................................................................................13
4.6.4 Operadores lgicos................................................................................................................................13
Pgina 22 .
4.6.5 Operadores miscelneos........................................................................................................................14
4.7 Estructuras de control _______________________________________________ 14
4.7.1 Selectivas. .............................................................................................................................................14
4.7.1.1 Simple. .............................................................................................................................................14
4.7.1.2 Doble. ..............................................................................................................................................15
4.7.1.3 Mltiple ...........................................................................................................................................15
4.7.2 Repetitivas.............................................................................................................................................16
4.7.2.1 while ................................................................................................................................................17
4.7.2.2 do while ...........................................................................................................................................17
4.7.2.3 for.....................................................................................................................................................17
4.7.3 Miscelneas...........................................................................................................................................18
4.7.3.1 break ................................................................................................................................................18
4.7.3.2 continue ...........................................................................................................................................18
4.8 Manejo de entrada y salida simple. _____________________________________ 18
4.9 ndice _____________________________________________________________ 22

Pgina 23

Ip4 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Ip4 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Tema 4 Lenguaje de programacin.

Você também pode gostar