UNIVERSIDAD DE LAS FUERZAS

ARMAS ESPE EXTENSIÓN

LATACUNGA
CARRERA DE INGENIERÍA
AUTOMOTRIZ
MATERIA: FUNDAMENTOS DE
PROGRAMACIÓN
NRC:5590

Junio del 2018

Latacunga-Ecuador

1
 Guía de Sintaxis de Lenguaje C
1. Estructura de un Programa.

2. Primer programa en C.

3. Palabras reservadas en C.

4. Directivas del Preprocesador.

5. Archivos de cabecera.

6. Comentarios.

7. Tipos de datos.

8. Variables.

9. Expresiones y operadores.

10. Funciones de entrada y salida.

11. Sentencias de control.

12. Funciones.

13. Estructura de datos.

14. Cadenas.

15. Estructuras.

2
 Estructura de un Programa.

Un programa en C es un conjunto de funciones, definiciones de tipos de datos y

declaraciones de variables contenidos en un conjunto de ficheros. Un programa en C
siempre comienza a ejecutar por la función con nombre main.

La primera línea indica que se tengan en cuenta las funciones y tipos definidos en la biblioteca
stdio (standard input/output). Estas definiciones se encuentran en el fichero de encabezado
(header) stdio.h.

En la función main se incluye una primera sentencia que llama a la función printf. Ésta toma
como argumento (encerrado entre paréntesis) una cadena de caracteres limitados por dobles
comillas " " y la imprime en la salida habitual, que generalmente es el terminal en el que
trabajamos. El símbolo \n indica un cambio de línea.

La segunda sentencia, return 0, termina el programa y devuelve un valor (cero) al sistema

operativo (por lo general es cero si la ejecución fue correcta y se usan valores distintos de cero
para indicar diversos errores que pudieron ocurrir). Si bien no es obligatorio terminar el programa
con un return, es conveniente indicarle a quien lo haya invocado, sea el Sistema Operativo o
algún otro programa, si la finalización ha tenido éxito o no. De cualquier manera, en este caso, si
sacamos esa sentencia el programa, éste funcionará exactamente igual, pero al ser compilado, el
compilador nos advertirá de la falta de retorno.

La inclusión de comentarios en un programa es una saludable práctica, como lo reconocerá

cualquiera que haya tratado de leer un listado hecho por otro programador o por sí mismo, varios

3
meses atrás. Para el compilador, los comentarios son inexistentes, por lo que no generan líneas de
código, permitiendo abundar en ellos tanto como se desee. En el lenguaje C se toma como
comentario todo carácter entre los símbolos: /* */.

Cada sentencia de programa queda finalizada por el terminador ";", que indica al compilador el
fin de la misma. Esto es necesario ya que sentencias complejas pueden llegar a tener más de un
renglón, y habrá que avisar al compilador donde terminan. Es perfectamente lícito escribir
cualquier sentencia abarcando los renglones que la misma necesite; por ejemplo podría ser:

printf("Bienvenido a la programación

en lenguaje C\n") ;
En general, un programa suele estar compuesto de tres partes:

• El encabezamiento, que especifica las declaraciones globales de los datos y sus tipos, que
vamos a manejar a lo largo del programa;
• La función principal, que se suele llamar main, y define la estructura del programa.
• Las funciones o subrutinas auxiliares, que realizan las operaciones necesarias; son
llamadas por la rutina principal, la función main. Se suelen colocar después de esta
función.

4
 Primer Programa en C.

En el libro "El Lenguaje de Programación C", Kernighan y Ritchie introdujeron al lenguaje C

utilizando un sencillo programa que mostraba un saludo por la pantalla. Desde entonces se hizo
tradición empezar con cualquier lenguaje de programación con el ejemplo del “Hola mundo”.

En particular en C se involucran muchas partes y sintaxis del lenguaje, por lo cual es especialmente
útil verlo como el primer ejemplo de programación en C.

Palabras Reservadas en C.
Las palabras reservadas son identificadores predefinidos (tienen un significado especial). En todos
los lenguajes de programación existe un conjunto de palabras reservadas.
El lenguaje C está formado por un conjunto pequeño de palabras clave (reservadas) o comandos
(keywords), y una serie de operadores. Hay cerca de 40 palabras clave, frente a las 150 del BASIC
o 200 que poseen otros lenguajes, como el COBOL y el PASCAL. Estas palabras son:

5
 Directivas del Procesador.
Las siguientes directivas del preprocesador de lenguaje C se encuentran
disponibles:
Estas directivas son las siguientes: #define, #elif, #else, #endif, #error, #if,
#ifdef, #ifndef, #include, #message y #undef.

Sintaxis

#define label text

#elif condition
#else
#endif
#error "message"
#if condition
#ifdef label
#ifndef label
#include {"filename" | <filename>}
#message "message"
#undef label

Parámetros

• condition: Una de la siguientes.

Una expresión absoluta: La expresión no debe contener referencias

hacia delante o externas y cualquier valor distinto de cero es
considerado como verdadero.

string1 = string2 : La condición es verdadera si la cadena1 y la cadena2

tienen la misma longitud y contenido.

string1 < > string2 : La condición es verdadera si la cadena1 y la

cadena2 tienen distinta longitud o contenido.

• filename: Nombre del archivo que se va a incluir.

• label: Símbolo a definir, anular definición o a examinar (tested).
• message: Texto que se va a visualizar.
• text: Valor que se va a asignar.

6
Descripción

Etiquetas de definición y de anulación de definición

Utilice #define para definir una etiqueta temporal.

#define label value

es similar a:

label VAR value

Utilice #undef para anular la definición de una etiqueta; el efecto es como si no

hubiera sido definido.

Directivas condicionales

Utilice las directivas #if ... #else ... #endif para controlar el proceso de
ensamblado. Si la condición que sigue a la directiva #if no es verdadera, las
siguientes instrucciones no generarán ningún código hasta que se encuentre una
directiva #endif o #else.

Todas las directivas de ensamblador (excepto END) e inclusiones de archivos

pueden ser deshabilitadas por las directivas condicionales. Cada directiva #if
debe acabar con la directiva #endif. La directiva #else es opcional, y si se usa,
debe estar en un bloque #if ... #endif.

Los bloques #if ... #endif e #if ... #else ... #endif pueden estar anidados.

Utilice #ifdef para ensamblar instrucciones por encima de la siguiente directiva

#else o #endif sólo si el símbolo está definido.

Utilice #ifndef para ensamblar instrucciones por encima de la siguiente

directiva #else o #endif sólo si el símbolo no está definido.

Utilice #include para insertar el contenido de un archivo en un archivo fuente

en un punto específico.

Visualización de errores

Utilice #error para forzar al ensamblador a generar un error.

7
Definición de comentarios

Utilice /*...*/ para comentar secciones del listado de ensamblador.

Utilice // para marcar el resto de la línea como comentario.

Ejemplos

Utilización de las directivas condicionales

El siguiente ejemplo define las etiquetas "tweek" y "adjust". Si "adjust" está

definido, entonces el registro 16 es decrementado por un valor que depende de
"adjust", en este caso 30.

#define tweek 1
#define adjust 3

#ifdef tweek
#if adjust = 1
SUBI R16, 4
#elif adjust = 2
SUBI R16, 20
#elif adjust = 3
SUBI R16, 30
#endif
#endif /* ifdef tweek*/

Inclusión de un archivo fuente

El siguiente ejemplo utiliza #include para incluir un archivo que define macros
en un archivo fuente. Por ejemplo, las siguientes macros pueden definirse en
"macros.s90".

xch MACRO a, b
PUSH a
MOV a, b
POP b
ENDM

Las definiciones de las macros pueden entonces ser incluidas, utilizando

#include, como en el siguiente ejemplo.

8
 NAME include

; standard macro definitions

#include "macros.s90"

; program
main: xch R16, R17
RET
END main
Archivos de Cabecera.

Los principales archivos de cabecera de C suelen ser los siguientes:

ctype.h: Funciones útiles para la clasificación y el mapeado de códigos.

errno.h: Funciones que permiten comprobar el valor almacenado en errno por algunas funciones
de librerías.
float.h: Funciones que establecen algunas propiedades de las representaciones de tipos real.
limits.h: Funciones que establecen algunas propiedades de las representaciones de tipos enteros.
math.h: Funciones que sirven para realizar operaciones matemáticas comunes sobre valores de
tipo double.
stdarg.h: Son declaraciones que permiten acceder a los argumentos adicionales sin nombre en una
función que acepta un número variable de argumentos.
stdio.h: Macros y funciones para realizar operaciones de entrada y salida sobre ficheros y flujos
de datos.
stdlib.h y a veces unistd.h: Declaraciones de una colección de funciones útiles y la definición de
tipos y macros para usarlas. Entre ellas suele estar la función malloc que permite hacer peticiones
de memoria dinámica al sistema.
string.h: Declaración de una colección de funciones útiles para manejar cadenas y otros arrays de
caracteres.
time.h: Declaración de funciones para el manejo de fechas.

Comentarios.

Un “comentario” es una secuencia de caracteres que comienza con una combinación de barra
diagonal/asterisco (/*) que el compilador trata como un único carácter de espacio en blanco y se
pasa por alto de cualquier otra manera.

Un comentario puede incluir cualquier combinación de caracteres del juego de caracteres

representable, incluidos los caracteres de nueva línea, salvo el delimitador de "final de comentario"
(*/). Los comentarios pueden ocupar más de una línea, pero no se pueden anidar.

Los comentarios pueden aparecer en cualquier lugar en el que se permita un carácter de espacio
en blanco. Dado que el compilador trata un comentario como si fuese un único carácter de espacio
en blanco, no se pueden incluir comentarios dentro de tokens. El compilador omite los caracteres
del comentario.

9
Use comentarios para documentar el código. Este ejemplo es un comentario admitido por el
compilador:

Tipos de Datos.

C ofrece tres tipos de datos básicos:

• Números enteros definidos con la palabra clave int

• Letras o caracteres definidos con la palabra clave char
• Números reales o en coma flotante definidos con las palabras claves float o double

Enteros

Se definen con “int” y admiten de forma opcional dos prefijos modificadores:

• “short” y “long”: Modifica el tamaño en bits del entero. Existen por tanto tres tipos de
enteros: “int”, “short int” (que se puede abreviar como “short”), y “long int” (que
se puede abreviar como “long”).

El lenguaje C no define tamaños fijos para sus tipos de datos básicos. Lo único que
garantiza es que un short int tiene un tamaño menor o igual que un int y este a su vez
un tamaño menor o igual a un long int. Esta característica del lenguaje ha complicado la
creación de programas que sean compatibles entre varias plataformas.

• “unsigned”: define un número natural (mayor o igual a cero).

10
 Variables.

Una variable es un objeto nombrado capaz de contener un dato que puede ser modificado durante
la ejecución de programa.

En C, las variables tienen tipo, que significa que es necesario especificar el tipo de dato que se le
asigna a una variable (int, float etc.). Las variables se almacenan en la memoria RAM y el espacio
de memoria que ocupan (en bytes) depende de su tipo.

Una constante tiene las mismas características que una variable excepto el hecho de que su valor
asignado no puede ser cambiado durante la ejecución de programa.

A diferencia de las variables, las constantes se almacenan en la memoria Flash del

microcontrolador para guardar el mayor espacio posible de memoria RAM. El compilador las
reconoce por el nombre y el prefijo const. En mikroC, el compilador reconoce automáticamente el
tipo de dato de una constante, así que no es necesario especificar el tipo adicionalmente.

Expresiones y operadores.

Una expresión es una combinación de operadores y operandos de cuya evaluación se

obtiene un valor.

Los operandos pueden ser nombres que denoten objetos variables o constantes, funciones,
literales de cualquier tipo adecuado de acuerdo con los operadores u otras expresiones más
simples. La evaluación de una expresión da lugar a un valor de algún tipo, una expresión
se dice que es del tipo de su resultado.
Ejemplos de expresiones:

11
 Las expresiones se evalúan de acuerdo con la precedencia de los operadores. Ante una
secuencia de operadores de igual precedencia, la evaluación se realiza según el orden de
escritura, de izquierda a derecha. El orden de evaluación puede modificarse usando
paréntesis.

Ada agrupa los operadores en 6 categorías, de menor a mayor precedencia. Los

operadores binarios se usan en formato infijo (<operando_izquierdo> <operador>
<operando_derecho>), como en "a + b". Los operadores unarios se usan en formato
prefijo (<operador> <operando> ), como en "-5".

Operadores lógicos.

Están predefinidos para cualquier tipo, T, que designe un booleano, modular o un array
monodimensional de componentes booleanos:

Operadores relacionales.

Los operadores de igualdad están predefinidos para todos los tipos no limitados. Sea T un tipo con
estas características:

function "=" (Left, Right : T) return Boolean

function "/="(Left, Right : T) return Boolean

Los operadores de ordenación están predefinidos para todos los tipos escalares y los arrays de
elementos discretos. Sea T un tipo con estas características:

function "<" (Left, Right : T) return Boolean

function "<="(Left, Right : T) return Boolean
function ">" (Left, Right : T) return Boolean
function ">="(Left, Right : T) return Boolean

12
Existe también un operador de pertenencia ("in", "not in") que determina si un valor pertenece a
un rango o a un subtipo: if i in 1..10 then ...

Todos los operadores relacionales devuelven un resultado de tipo Boolean.

Ejemplo de uso en expresiones (sean A, B de tipo T y C de tipo Boolean):

if A = B then ...
C := (A <= B);
return (A >= B);

Operadores binarios de adición.

Los operadores de adición predefinidos para cualquier tipo numérico, T, son:

function "+"(Left, Right : T) return T

function "–"(Left, Right : T) return T

Ejemplo de uso en expresiones (sean A, B y C de tipo T):

C := A + B;
return (A - B);

También pertenecen a esta categoría los operadores de concatenación, predefinidos para

cualquier tipo de array monodimensional no limitado, T, de elementos de tipo C:

function "&"(Left : T; Right : T) return T

function "&"(Left : T; Right : C) return T
function "&"(Left : C; Right : T) return T
function "&"(Left : C; Right : C) return T

Operadores unarios de adición.

Los operadores unarios de adición predefinidos para cualquier tipo númerico, T, son la identidad
y la negación:

function "+"(Right : T) return T

function "–"(Right : T) return T

Ejemplo de uso en expresiones (sean A y B de tipo T):

B := -A;

Cuando se aplica a un tipo modular, el operador de negación ("-") tiene el efecto de restar el
valor del operando, si es distinto de cero, al módulo. Si el valor del operando es cero, el resultado
es cero.

13
Operadores multiplicativos.

Los operadores de multiplicación y división están predefinidos entre diversas combinaciones de

enteros y reales:

function "*" (Left, Right : T) return T

function "/" (Left, Right : T) return T
function "*"(Left : T; Right : Integer) return T
function "*"(Left : Integer; Right : T) return T
function "/"(Left : T; Right : Integer) return T
function "*"(Left, Right : root_real) return root_real
function "/"(Left, Right : root_real) return root_real
function "*"(Left : root_real; Right : root_integer) return root_real
function "*"(Left : root_integer; Right : root_real) return root_real
function "/"(Left : root_real; Right : root_integer) return root_real
function "*"(Left, Right : universal_fixed) return universal_fixed
function "/"(Left, Right : universal_fixed) return universal_fixed

Ejemplo de uso en expresiones (sean A, B y C del mismo tipo entero o real):

C := A * B;
return (A / B);

Los operadores módulo y resto están definidos para cualquier tipo entero, T:

function "mod"(Left, Right : T) return T

function "rem"(Left, Right : T) return T

La relación entre el resto y la división entera viene dada por la expresión: A = (A/B)*B + (A rem
B), donde (A rem B) tiene el mismo signo que A, y es menor que B en valor absoluto.

El operador módulo se define de manera que (A mod B) tiene el mismo signo que B, un valor
absoluto menor, y existe un número entero, N, tal que: A = B*N + (A mod B).

Ejemplo de uso en expresiones (sean A, B y C de tipo T):

C := A rem B;
return (A mod B);

Operadores de máxima prioridad.

Los operadores de máxima prioridad son: el operador de cálculo del valor absoluto, definido para
cualquier tipo numérico, T1, el operador de negación lógica, definido para cualquier tipo
booleano, modular o array monodimensional de componentes booleanos, T 2, y el operador de
exponenciación, definido para cualquier tipo entero, T3, o para cualquier tipo real en coma
flotante, T4. Cada uno, de acuerdo con las siguientes especificaciones:

14
function "abs"(Right : T) return T
function "not"(Right : T) return T
function "**"(Left : T; Right : Natural) return T
function "**"(Left : T; Right : Integer'Base) return T

Ejemplo de uso en expresiones (sean A, B de tipo T1; C, D de tipo T2 y E de tipo T3):

A := abs(B);
C := not D;
return (E ** 3); -- E elevado al cubo.

Funciones de entrada y salida.

A diferencia de otros lenguajes, C no dispone de sentencias de entrada/salida . En su lugar se

utilizan funciones contenidas en la librería estándar y que forman parte integrante del lenguaje.

Las funciones de entrada/salida (Input/Output) son un conjunto de funciones, incluidas con el

compilador, que permiten a un programa recibir y enviar datos al exterior. Para su utilización es
necesario incluir, al comienzo del programa, el archivo stdio.h en el que están definidos sus
prototipos:

#include <stdio.h>

donde stdio proviene de standard-input-output .

Función printf()

La función printf() imprime en la unidad de salida (el monitor, por defecto), el texto, y las
constantes y variables que se indiquen. La forma general de esta función se puede estudiar
viendo su prototipo :

int printf("cadena_de_control", tipo arg1, tipo arg2, ...)

Función scanf()

La función scanf() es análoga en muchos aspectos a printf() , y se utiliza para leer datos de la
entrada estándar (que por defecto es el teclado). La forma general de esta función es la siguiente:

int scanf("%x1%x2...", &arg1, &arg2, ...);

Macros getchar() y putchar()

Las macros 6 getchar() y putchar() permiten respectivamente leer e imprimir un sólo carácter
cada vez, en la entrada o en la salida estándar. La macro getchar() recoge un carácter
introducido por teclado y lo deja disponible como valor de retorno. La macro putchar() escribe
en la pantalla el carácter que se le pasa como argumento. Por ejemplo:

15
putchar('a');
escribe el carácter a . Esta sentencia equivale a printf("a");

Sentencias de Control.

Condicional if

La sentencia if («si») ejecuta las instrucciones sólo si se cumple una condición. Si la condición
es falsa, no se hace nada:

La sintaxis es la siguiente:

if condición:
sentencias

Por ejemplo, el siguente programa felicita a alguien que aprobó la asignatura:

nota = int(raw_input('Ingrese su nota: '))

if nota >= 55:
print 'Felicitaciones'

Ejecute este programa, probando varias veces con valores diferentes.

Condicional if-else

La sentencia if-else («si-o-si-no») decide qué instrucciones ejecutar dependiendo si una

condición es verdadera o falsa:

La sintaxis es la siguiente:

if condición:
qué hacer cuando la condición es verdadera
else
qué hacer cuando la condición es falsa

Por ejemplo, el siguiente programa indica a alguien si es mayor de edad:

edad = int(raw_input('Cual es su edad? '))

if edad < 18:
print 'Usted es menor de edad'
else:
print 'Usted es adulto'

El siguiente programa realiza acciones distintas dependiendo de si el número de entrada es par o

impar:

16
n = int(raw_input('Ingrese un numero: '))
if n % 2 == 0:
print 'El numero es par'
print 'La mitad del numero es', n / 2
else:
print 'El numero es impar'
print 'El sucesor del numero es', n + 1
print 'Listo'

La última sentencia no está indentada, por lo que no es parte del condicional, y será ejecutada
siempre.

Condicional if-elif-else

La sentencia if-elif-else depende de dos o más condiciones, que son evaluadas en orden. La
primera que es verdadera determina qué instrucciones serán ejecutadas:

La sintaxis es la siguiente:

if condición1:
qué hacer si condición1 es verdadera
elif condición2:
qué hacer si condición2 es verdadera
...
else:
qué hacer cuando ninguna de las
condiciones anteriores es verdadera

El último else es opcional.

Por ejemplo, la tasa de impuesto a pagar por una persona según su sueldo puede estar dada por la
siguiente tabla:

sueldo tasa de impuesto

menos de 1000 0%

1000 ≤ sueldo < 2000 5%

2000 ≤ sueldo < 4000 10%

4000 o más 12%

Entonces, el programa que calcula el impuesto a pagar es el siguiente:

17
sueldo = int(raw_input('Ingrese su sueldo: '))
if sueldo < 1000:
tasa = 0.00
elif sueldo < 2000:
tasa = 0.05
elif sueldo < 4000:
tasa = 0.10
else:
tasa = 0.12
print 'Usted debe pagar', tasa * sueldo, 'de impuesto'

Siempre sólo una de las alternativas será ejecutada. Apenas una de las condiciones es verdadera,
el resto de ellas no siguen siendo evaluadas.

Otra manera de escribir el mismo programa usando sólo sentencias if es la siguiente:

sueldo = int(raw_input('Ingrese su sueldo: '))

if sueldo < 1000:
tasa = 0.00
if 1000 <= sueldo < 2000:
tasa = 0.05
if 2000 <= sueldo < 4000:
tasa = 0.10
if 4000 < sueldo:
tasa = 0.12
print 'Usted debe pagar', tasa * sueldo, 'de impuesto'

Esta manera es menos clara, porque no es evidente a primera vista que sólo una de las
condiciones será verdadera.

Ciclo while

El ciclo while («mientras») ejecuta una secuencia de instrucciones mientras una condición sea
verdadera:

Cada una de las veces que el cuerpo del ciclo es ejecutado se llama iteración.

La condición es evaluada antes de cada iteración. Si la condición es inicialmente falsa, el ciclo

no se ejecutará ninguna vez.

La sintaxis es la siguiente:

while condición:

18
 sentencias

Por ejemplo, el siguiente programa multiplica dos números enteros sin usar el operador *:

m = int(raw_input())
n = int(raw_input())
p=0
while m > 0:
m=m-1
p=p+n
print 'El producto de m y n es', p

Para ver cómo funciona este programa, hagamos un ruteo con la entrada m = 4 y n = 7:

p m n

14

21

28

En cada iteración, el valor de m decrece en 1. Cuando llega a 0, la condición del while deja de
ser verdadera por lo que el ciclo termina. De este modo, se consigue que el resultado sea sumar
m veces el valor de n.

Note que el ciclo no termina apenas el valor de m pasa a ser cero. La condición es evaluada una
vez que la iteración completa ha terminado.

19
En general, el ciclo while se utiliza cuando no es posible saber de antemano cuántas veces será
ejecutado el ciclo, pero sí qué es lo que tiene que ocurrir para que se termine.

Ciclo for con rango

El ciclo for con rango ejecuta una secuencia de sentencias una cantidad fija de veces.

Para llevar la cuenta, utiliza una variable de control que toma valores distintos en cada
iteración.

Una de las sintaxis para usar un for con rango es la siguiente:

for variable in range(fin):

qué hacer para cada valor de la variable de control

En la primera iteración, la variable de control toma el valor 0. Al final de cada iteración, el valor
de la variable aumenta automáticamente. El ciclo termina justo antes que la variable tome el
valor fin.

Por ejemplo, el siguiente programa muestra los cubos de los números del 0 al 20:

for i in range(21):
print i, i ** 3

Un rango es una sucesión de números enteros equiespaciados. Incluyendo la presentada más

arriba, hay tres maneras de definir un rango:

range(final)
range(inicial, final)
range(inicial, final, incremento)

El valor inicial siempre es parte del rango. El valor final nunca es parte del rango. El incremento
indica la diferencia entre dos valores consecutivos del rango.

Si el valor inicial es omitido, se supone que es 0. Si el incremento es omitido, se supone que es 1.

Con algunos ejemplos quedará más claro:

range(9) 0, 1, 2, 3, 4, 5, 6, 7, 8

range(3, 13) 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

range(3, 13, 2) 3, 5, 7, 9, 11

range(11, 4) ningún valor

20
range(11, 4, -1) 11, 10, 9, 8, 7, 6, 5

Usando un incremento negativo, es posible hacer ciclos que van hacia atrás:

for i in range(10, 0, -1):

print i
print 'Feliz anno nuevo!'

En general, el ciclo for con rango se usa cuando el número de iteraciones es conocido antes de
entrar al ciclo.

Salir de un ciclo

Además de las condiciones de término propias de los ciclos while y for, siempre es posible salir
de un ciclo en medio de una iteración usando la sentencia break. Lo lógico es que sea usada
dentro de un if, para evitar que el ciclo termine prematuramente en la primera iteración:

Por ejemplo, en el programa para determinar si un número es primo o no, la búsqueda de

divisores puede ser terminada prematuramente apenas se encuentra el primero de ellos:

es_primo = True
for d in range(2, n):
if n % d == 0:
es_primo = False
break
Saltar a la siguiente iteración

La sentencia continue se usa para saltar a la iteración siguiente sin llegar al final de la que está
en curso.

Por ejemplo, el siguiente programa muestra el seno, el coseno y la tangente de los números del 1
al 30, pero omitiendo los que terminan en 7:

from math import sin, cos, tan

for i in range(1, 31):
if i % 10 == 7:
continue
print i, sin(i), cos(i), tan(i)

21
 Funciones.

Las funciones suelen encapsular una operación más o menos compleja de la que se deriva un
resultado. Para ejecutar esta operación, las funciones pueden precisar la invocación de otras
funciones (o incluso de ellas mismas como es el caso de las funciones recursivas).

Las funciones en un programa son entidades que dado un conjunto de datos (los parámetros), se
les encarga realizar una tarea muy concreta y se espera hasta obtener el resultado. Lo idóneo es
dividir tareas complejas en porciones más simples que se implementan como funciones. La
división y agrupación de tareas en funciones es uno de los aspectos más importantes en el diseño
de un programa.

1. Definición de funciones

Las funciones en C tienen el siguiente formato:

tipo_del_resultado NOMBRE(tipo_param1 param1, tipo_param2 param2, ... )

{
/* Cuerpo de la función */
}

Cuando se invoca una función se asignan valores a sus parámetros y comienza a ejecutar el
cuerpo hasta que se llega al final o se encuentra la instrucción return. Si la función devuelve un
resultado, esta instrucción debe ir seguida del dato a devolver. Por ejemplo:

1 int search(int table[], int size)

2 {
3 int i, j;
4 if (size == 0)
5 {
6 return 0;
7 }
8 j = 0;
9 for (i = 0; i < size; i++)
10 {
11 j += table[i];
12 }
13 return j;
14 }

La ejecución de la función comienza en la línea 4. Si el parámetro size tiene valor cero, la

función termina y devuelve el valor cero. Si no, se ejecuta el bucle y se devuelve el valor de la
variable j. El tipo de la expresión que acompaña a la instrucción return debe coincidir con el
tipo del resultado declarado en la línea 1.

La llamada a una función se codifica con su nombre seguido de los valores de los parámetros
separados por comas y rodeados por paréntesis. Si la función devuelve un resultado, la llamada
se reemplaza por su resultado en la expresión en la que se incluye. Por ejemplo:

22
1 int addition(int a, int b)
2 {
3 return (a + b);
4 }
5 int main()
6 {
7 int c;
8 c = c * addition(12, 32);
9 }

Estructura de Datos.

Las estructuras de datos no solo representan la información, también tienen un comportamiento

interno, y se rige por ciertas reglas/restricciones dadas por la forma en que esta construida
internamente.

Las estructuras de datos nos permiten resolver un problema de manera más sencilla gracias a que
las reglas que las rigen nunca cambian, así que puedes asumir que ciertas cosas son siempre ciertas.

Cadenas.

Las cadenas de caracteres (también llamadas cadenas o strings) son un tipo particular de vectores,
que como su nombre lo dice son vectores de char, con la particularidad que tienen una marca en
el fin del (el caracter '\0'), además el lenguaje nos permite escribirlas como texto dentro de comillas
dobles si son simples no. Veamos unos ejemplos de su declaración:

Estructuras.

Las estructuras son colecciones de variables relacionadas bajo un nombre.

Las estructuras pueden contener variables de muchos tipos diferentes de datos
- a diferencia de los arreglos que contienen unicamente elementos de un mismo
tipo de datos.

Definición de estructuras

Las estructuras son tipos de datos derivados están construidas utilizando objetos de otros tipos.
Considere la siguiente definición de estructura:

23
struct ejemplo
{
char c;
int i;
}
;
La palabra reservada struct indica se est ́a definiendo una estructura. El identificador ejemplo es
el nombre de la estructura. Las variables declaradas dentro de las llaves de la definici ́on de
estructura son los miembros de la estructura. Los miembros de la misma estructura deben tener
nombres ́unicos
mientras que dos estructuras diferentes pueden tener miembros con el mismo
nombre.
Cada definición de estructura debe terminar con un punto y coma.
La definición de struct ejemplo contiene un miembro de tipo char y otro
de tipo int.
Los miembros de una estructura pueden ser variables de los tipos
de datos básicos (int, char, float,etc) o agregados como ser arreglos y otras
estructuras. Una estructura no puede contener una instancia de si misma.
Declaramos variables del tipo estructura del siguiente modo:
struct ejemplo e1, a[10];
o alternativamente sin usar la palabra struct:
ejemplo e1, a[10];
Las declaraciones anteriores declaran variables e1 de tipo ejemplo y a de tipo
arreglo de ejemplo de dimensi ́on 10.
Se pueden declarar variables de tipo estructura ejemplo colocando sus nom-
bres a continuaci ́on de la llave de cierre de la definici ́on de estructura y el punto
y coma, en el caso anterior:
struct ejemplo
{
char c;
int i;
}
e1, a[10];
1

24
 Bibliografía:
Fundamentos de programación: http://zacabag1.blogspot.com/. Recuperado el 19/06/2018.
Funciones de entrada y de salida: http://www.juntadeandalucia.es/averroes/centros-
tic/14005663/helvia/aula/archivos/repositorio/0/230/html/lenguajec/unidad8.htm. Recuperado el
19/06/2018.
Estructura en C: http://c.conclase.net/curso/?cap=011. Recuperado el 19/06/2018.

25