Manual laboratorio de programación i

Manual de Laboratorio
de programación I.
Universidad Centroamericana.
Facultad de Ciencias, Tecnología y Ambiente.
Ingeniería en Sistemas de Información.
2 4 / 0 8 / 2 0 1 6
Autor: Jeffrey Noel Calero Chávez.
Profesor Elsner González.

Autor: Jeffrey Noel Calero Chávez. 1
I. Índice
I. Índice...................................................................................1
II. Tipos de datos .......................................................................3
III.Declaración de variables ..........................................................3
IV. Casting.................................................................................4
V. Arreglos................................................................................4
A. Arreglos unidimensionales.............................................................................................. 4
B. Arreglos bidimensionales................................................................................................ 5
VI. Estructuras............................................................................6
VII. Entrada y salida formateada................................................7
C. Scanf ............................................................................................................................. 7
D. Printf............................................................................................................................. 8
VIII. Entrada y salida sin formato .............................................. 16
IX. Ficheros.............................................................................. 17
E. Fseek............................................................................................................................17
X. Estructuras de control ........................................................... 18
F. If ..................................................................................................................................18
G. If/else...........................................................................................................................18
H. Switch...........................................................................................................................18
XI. Estructura de control repetitiva o de iteración condicional ............ 19
I. Contadores, acumuladores, centinelas y banderas ..........................................................20
1.1.1 Contadores y acumuladores................................................................................20
1.1.2 Contador...........................................................................................................20
1.1.3 Acumulador o totalizador...................................................................................21
1.1.4 Centinela...........................................................................................................21
1.1.5 Bandera.............................................................................................................21
J. Estructura de control repetitiva mientras (while) ............................................................21
K. Estructura de control repetitiva hacer_mientras (do while)..............................................22

L. Estructura de control repetitiva desde (for) ....................................................................22
XII. Funciones....................................................................... 22
M. Ventajas....................................................................................................................23
N. Funciones sin paso de parámetros..................................................................................23
O. Funciones con paso de parámetros ................................................................................23
P. Variables locales............................................................................................................23
Q. Variables globales..........................................................................................................24
R. Transferencia de variables. ............................................................................................24

II. Tipos de datos
En c podemos declarar diferentes tipos de variables entre estos están
los números enteros entre los cuales podemos encontrar:
 Int-cantidades enteros.
 Char-caracteres.
 Bool-(no existe en C)-valores lógicos.
 Enum-enumeraciones.
Aunque en C no existe el tipo de datos bool, se puede implementar el
número 0 como falso y cualquier otro número distinto a 0 como valor
verdadero.
También se puede ver a los números fraccionarios que se dividen en:
 Float-número en coma flotante.
 Doublé-número en coma flotante de doble precisión.
Además existe en C un tipo de dato más que representa a variables
que no poseen un valor alguno esa variable es cual es:
 Void-sin valor.
Este tipo de dato no regresa ningún valor un ejemplo de este tipo de
dato podría ser main ya que no regresa valor alguno, a menos que
posea un return porque de esa forma dicha función regresa un valor
entero.
III. Declaración de variables
Al declarar una variable se debe usar la siguiente sintaxis:
tipo_de_dato, nombre de la variable, valor que recibe la variable. Por

ejemplo:
Int x=25;
Char letra=’A’;
Bool sexo=true;
IV. Casting
El casting son conversiones en las que se puede convertir un tipo de
dato a otro como por ejemplo:
Int a;
Char L;
a= (int) L;
V. Arreglos.
A. Arreglos unidimensionales
En términos simples se puede definir un arreglo como una colección
finita, homogénea y ordenada de elementos.
Esto porque los arreglos tiene un número limitado de elementos,
además que todos los elementos deben ser del mismo tipo y porque se
puede definir el orden que tendrán los elementos.
En un arreglo todos los índices, es decir, la posición que ocuparan los
elementos en la memoria irán siempre dentro de corchetes ([]), como

por ejemplo:
Int a [5];
Los arreglos se pueden realizar de distintas formas entre las que
podemos encontrar las siguientes:
Int A [] = {11, 3, 9}; o también de esta otra forma:
Int A [3] = {11, 3, 9};
Estas son usadas para inicializar la variable y que valor tendrá cada
una de las posiciones de memoria.
B. Arreglos bidimensionales
Los arreglos bidimensionales, esta clase de arreglos consta de filas y
de columnas por tanto también son conocidos como matrices y es el
más utilizado. Al igual que arreglos unidimensionales, los
bidimensionales son finitos, homogéneos ya que todos los valores que
reciba la variable deben de ser del mismo tipo, y son ordenados.
A diferencia de los arreglos unidimensionales los bidimensionales
necesitaran de dos índices el primer índice representara la fila y el
segundo índice representara las columnas y que irán entre corchetes
([]). Por ejemplo:
Int A [2] [3];
En este ejemplo podemos notar que primero debemos definir el tipo de
la variable luego nombrar a la variable y finalmente indicar la posición
en fila y columnas en la que se encontrara.

VI. Estructuras
Las estructuras son colecciones de variables bajo un mismo nombre.
En las estructuras hay variables de distinto tipo y eso la diferencia de
los tipos de arreglos, aunque al igual que ellos es finita.
La estructura se debe realizar fuera de cualquier función esta
generalmente se hace en la parte superior aún antes de declarar
alguna variable.
Para crear una estructura primero comenzamos por definir el tipo de
estructura, para ello se procede de manera parecida a la definición de
una variable, con algunas modificaciones; en lenguaje C para definir
una estructura, se utiliza la palabra reservada struct, normalmente
seguida por un nombre y llave izquierda; después se define el tipo y
nombre para uno o más campos. Se permite cualquier definición de
tipo habitual, incluso punteros y estructuras.
Cada definición de campo acabará con un punto y coma. Por último se
coloca una llave derecha. Si hay campos del mismo tipo, se pueden
declarar en la misma línea, separándolos por comas. Sintaxis:
Struct ident_registro {
tipodato_1 campo_1;
tipodato_2 campo_2;
tipodato_3 campo_3; };
Hemos definido el tipo de dato ident_registro (nombre del registro),
pero aún no hay ninguna variable declarada con este nuevo tipo.
Observe en lenguaje C la necesidad de incluir un carácter (;) después
de cerrar las llaves. Para definir una variable de tipo registro se declara
de la misma forma que una variable:

ident_registro ident_variable;
Cada una de las variables que se encuentran dentro de la estructura se
la denomina “miembros”. Aunque también se le pueden usar las
siguientes denominaciones:
 Campo.
 Elemento.
 Atributo.
VII. Entrada y salida formateada
En el lenguaje C no podemos encontrar palabras reservadas para e/s
del sistema. Estas operaciones se realizan por medio de funciones ya
establecidas en la biblioteca de archivo de cabecera stdio.h. Las
entradas y salidas de datos con formatos se realizan con las funciones
printf (), y scanf ().
C. Scanf
La función scanf () sirve para la entrada de datos, esta nos permite
leer (introducir) datos desde el teclado asignarlos a una variable de C,
de acuerdo al formato ya definido; esta función usa la siguiente
sintaxis:
Scanf (“cadena de control”, argumento1, argumento2…);
La cadena de control permite hacer referencia al tipo de dato al que
pertenecen los argumentos que se están leyendo, y si se desea
también la anchura que posee el dato. Las cadenas de control siempre
van dentro de comillas (“”), además que están precedidas por el signo
%, seguidas por un carácter de conversión, los más usados se

presentan en la siguiente tabla:
Tipo de argumento. Tipo de dato. Cadena de control.
carácter Char %c
Entero decimal Int %d
Entero decimal sin
signo
Unsigned int %u
Entero corto decimal Short int %hd
Entero corto decimal
sin signo
Unsigned short int %hu
Entero corto decimal
con signo
Signed short int %d
Entero largo decimal Long int %ld
Entero largo decimal
sin signo
Unsigned long int %lu
Entero largo decimal
con signo
Signed long int %l
Real (punto flotante) Float %f
Puntero %p
La lista de argumentos serán las variables; scanf necesita saber la
posición de memoria de la computadora en que se encuentra la
variable para poder almacenar la información obtenida, para ello
utilizaremos el símbolo ampersand (&), que se colocara antes del
nombre de cada variable.
D. Printf
La función printf () se usa para la salida, en él se pueden escribir
textos y datos en la pantalla con determinado formato. Para esta
función usamos la siguiente sintaxis:
Printf (“cadena de control”, argumento1, argumento2…);
La cadena de control siempre se escribe dentro de comillas (“”) y

puede tener cualquiera de los siguientes elementos:
1. Los caracteres que se imprimirán en pantalla (los cuales se
visualizarán idénticos).
2. Secuencias de escape.
3. Uno o varios códigos de formatos , los cuales se presentan en la
tabla anterior.
Al igual que en la sentencia scanf un especificador o código de formato
se inicia con un carácter % y termina con un carácter de conversión;
Los argumentos pueden ser variables, constantes, o en general
expresiones de salida.
Como ejemplo podemos encontrar las siguientes estructuras con
formato:
estructura_Docente.
#include<stdio.h>
#include<stdlib.h>
Struct docente
{
Char nombre [25];
Char facultad [15];
Char correo [20];
Char clase [20];
Int celular;
Char carnet [15];

Float salario;
};
Int main ()
{
Struct docente datDoc [2];
Printf ("Ingrese la facultad a la que pertenecen");
Scanf ("%s", &datDoc [0].facultad);
Printf ("nIngrese su nombren");
Scanf ("%s", &datDoc [0].nombre);
Printf ("nIngrese su n243mero de carnetn");
Scanf ("%s", &datDoc [0].carnet);
Printf ("nDigite su correo electronicon");
Scanf ("%s", &datDoc [0].correo);
Printf ("nIngrese el nombre de la clase que imparten");
Scanf ("%s", &datDoc [0].clase);
Printf ("nIngrse su numero de celularn");
Scanf ("%d", &datDoc [0].celular);
Printf ("nIngrese su salarion");
Scanf ("%f", &datDoc [0].salario);

Return 0;
}
Estructura empleado
#include<stdio.h>
#include<stdlib.h>
struct Emp
{
Char nombre [25];
Char cedula [20];
Int edad;
float salario;
Char seguro;
Char puesto;
};
Int main ()
{

Struct Emp datE [2];
printf("Digite el nombre del empleadon");
scanf("%s",&datE[0].nombre);
printf("Digite la cedula del empleadon");
scanf("%s",&datE[0].cedula);
printf("Digite la edad del empleadon");
scanf("%d",&datE[0].edad);
printf("Digite el puesto que tiene el empleadon");
scanf("%s",&datE[0].puesto);
printf("Digite el carnet de seguro del empleadon");
scanf("%s",&datE[0].seguro);
printf("Digite el salario del empleadon");
scanf("%f",&datE[0].salario);
}
Estructura estudiante
#include<stdio.h>
#include<stdlib.h>
struct Est

{
char nombre[25];
int carnet;
int nota;
char facultad[25];
char carrera[25];
int edad;
char correo[20];
};
int main()
{
struct Est datEs[2];
printf("Ingrese el nombre del estudianten");
scanf("%s",&datEs[0].nombre);
printf("Ingrese su n243mero de carnetn");
scanf("%d",&datEs[0].carnet);
printf("Ingrese su correo electronicon");
scanf("%s",&datEs[0].correo);
printf("Digite la facultad al que pertenece el estudianten");

scanf("%s",&datEs[0].facultad);
printf("Ingrese la carrera del estudianten");
scanf("%s",&datEs[0].carrera);
printf("Digite la edad del estudianten");
scanf("%d",&datEs[0].edad);
printf("Ingrese la nota final obtenida por el estudianten");
scanf("%d",&datEs[0].nota);
return 0;
}
Estructura vehículo
#include<stdio.h>
#include<stdlib.h>
struct veh
{
char marca[25];
char modelo[25];
char cambio[10];
float precio;

};
int main()
{
struct veh datV[2];
system("color 0A");
printf("Digite la marca de vehiculon");
scanf("%s",&datV[0].marca);
printf("Digite el modelo del vehiculon");
scanf("%s",&datV[0].modelo);
printf("Digite el tipo de cambio del vehiculon");
printf("t manualn");
printf("t automaticon");
scanf("%s",&datV[0].cambio);
printf("Digite el precio del vehiculon");
scanf("%f",&datV[0].precio);
return 0;
}

VIII. Entrada y salida sin formato
Las funciones principales que realizan la entrada y salida sin formato
son:
Getche () Lee un carácter del teclado, no hay que esperar hasta que se
pulse la tecla <enter>. Visualiza el eco del carácter.
Getchar () Lee un carácter del teclado, espera hasta que se pulsa la
tecla <enter>.
Getch () Lee un carácter del teclado, no hay que esperar que se pulse
la tecla <enter>. No visualiza el eco del carácter.
Putchar () Imprime un carácter en la pantalla en la posición actual del
cursor.
Gets () Lee una cadena de caracteres introducida por el teclado.
Puts () Imprime una cadena en la pantalla, seguida de un carácter de
salto de línea.
Además de ellas usamos otras funciones como las siguientes:
Fflush (stdin) Limpia el buffer (memoria intermedia) utilizado por la
entrada estándar del sistema, generalmente el teclado.
Fflush (stdout) La función printf no escribe directamente en la pantalla,
sino en una memoria intermedia (buffer). Cuando este buffer
(memoria intermedia) se llena o cuando oprimimos un carácter ‘n’ es
cuando se envía el texto a la pantalla. La función fflush (stdout) lo que
hace es enviar a la pantalla lo que hay en ese buffer.

IX. Ficheros
Un archivo es un conjunto de bits almacenados en un dispositivo de
memoria secundaria, el cual puede ser almacenado con un conjunto de
propiedades y recuperados de la misma manera por el sistema
operativo para que un programa tenga acceso a este.
Un archivo es identificado por un nombre y la descripción de la carpeta
o directorio que lo contiene.
Los archivos digitales se llaman así porque son los equivalentes
digitales de los archivos en tarjetas, papel o microfichas del entorno de
oficina tradicional. Podemos encontrar dos tipos de archivos; archivos
de texto y archivos binarios.
Para poder trabajar con un archivo asociamos una estructura de tipo
FILE con un archivo especifico realizando una operación de apertura.
E. Fseek
Cuando se lee un dato de un fichero y después el que está a
continuación a él, y así sucesivamente, se dice que está realizando una
lectura secuencial del mismo. La función permite situarse en un
determinado dato del fichero es:
Fseek (fichero, posición, origen);
Si no existe ningún error la función devuelve un 0. Coloca el puntero
del fichero a tanto Bytes del origen como indica la posición contando a
partir del origen señalado. Los posibles orígenes son:
SEEK_SET o 0- principio del fichero.
SEEK_CUR o 1- posición actual.

SEEK_END o 2- final del fichero.
X. Estructuras de control
F. If
Estructura de control que dirige a la computadora para ejecutar una o
más instrucciones solamente si la condición es verdadera. Si la
condición es falsa no realiza ninguna acción. El término condición lo
utilizaremos a lo largo de este libro para referirnos a una o más
condiciones.
Existen dos formas de representarlo, dependiendo del número de
instrucciones que se desean realizar si la condición se cumple.
G. If/else
Estructura de control que dirige a la computadora para ejecutar una
acción si la condición es verdadera, y otra acción en caso de que sea
falsa. Cabe mencionar que las instrucciones deberán ser diferentes en
cada caso, ya que si fueran iguales no se requeriría una estructura
selectiva, con la estructura secuencial se resolvería el problema.
Existen dos formas de representarlo, dependiendo del número de
instrucciones que se desean realizar si la condición se cumple o no.
H. Switch
Esta estructura selecciona entre varias posibilidades, dependiendo del
valor de la expresión. Cuando en la estructura si (if) todas las
condiciones utilizan la igualdad de una variable determinada con
constantes predefinidas, se puede utilizar la instrucción segun_sea
(switch), en dicha instrucción existen más de dos opciones.

La estructura segun_sea (switch) evalúa una expresión que puede
tomar n valores distintos; según con cuál de estos valores coincida, se
ejecutarán ciertas acciones, es decir, el programa o algoritmo seguirá
un determinado camino entre los n posibles. Dicha expresión sólo
acepta valores enteros o caracteres para entrar a la opción y el
operador de relación es el igual.
Se compara la “expresión” (puede ser una sola variable) con cada
una de las opciones “const” y en el momento de encontrar una
constante idéntica se ejecutan la(s) instrucción(es) correspondiente(s)
a ese caso. Al terminar de realizar las instrucciones del caso, se debe
usar la palabra reservada salir (break) para que vaya al final de la
estructura. Si ninguno de los casos cumple con la expresión, se puede
definir un caso por omisión, que también puede tener instrucciones; la
computadora ejecutará la sentencia caso contrario (default). El default
es opcional, si no está presente no se hace nada. Hay tres puntos que
debemos considerar en la sentencia segun_sea (switch):
1. Se diferencia del sí (if) en que el primero sólo puede comprobar por
igualdad, mientras que la expresión condicionada del sí (if) puede ser
de cualquier tipo.
2. No puede tener dos constantes en los casos con idénticos valores en
el mismo segun_sea (switch).
3. La sentencia segun_sea (switch) es más eficiente que el si anidado
si-si no-si (if-else-if).
XI. Estructura de control repetitiva o de iteración
condicional
La repetición de una acción (una o varias instrucciones) se lleva a cabo
mientras se cumpla cierta condición; para que la acción termine, la
acción misma debe modificar la(s) variable(s) de control que

interviene(n) en la condición. Dicha condición puede estar predefinida
como en el ciclo desde (for); o no predeterminada, como en los bucles
mientras (while) y hacer-mientras (do_while).
Bucles, ciclo o iteración. Es un segmento de un algoritmo o programa,
cuya(s) instrucción(es) se repite(n) un número conocido o indefinido
de veces mientras se cumpla una determinada condición.
I. Contadores,acumuladores,centinelas y banderas
1.1.1 Contadores y acumuladores
Estas dos palabras se usan mucho en programación para referirse a
variables que van incrementando o decrementando su valor a lo largo
de la ejecución del algoritmo o programa. Normalmente serán de tipo
numérico, Características de la variable contador o acumulador:
1. Se debe inicializar antes de entrar al ciclo.
2. Dentro del ciclo debe aparecer a ambos lados de la asignación.
Debemos inicializarlas de forma correcta, para:
• Sumar o restar en cero antes de entrar al ciclo; recordar que el cero
es el elemento neutro de la suma y resta.
• Multiplicar 1, porque si valen cero todo lo que multipliquemos por
ella seguirá valiendo cero; recordar que el 1 es el elemento neutro de
la multiplicación.
1.1.2 Contador
Un contador es una forma de controlar a un bucle. Es una variable
cuyo valor se incrementa o decrementa en una cantidad constante
cada vez que se produce un determinado suceso o acción en cada
repetición; dicha variable controla o determina la cantidad de veces

que se repite un proceso o dato.
1.1.3 Acumulador o totalizador
Un acumulador realiza la misma función que un contador con la
diferencia de que el incremento o decremento es variable en lugar de
constante.
Es una variable que acumula sobre sí misma un conjunto de valores,
para de esta manera tener la acumulación de todos ellos en una sola
variable. Es una variable que almacena cantidades resultantes de
operaciones sucesivas.
1.1.4 Centinela
El centinela es una variable que inicia con un valor, luego dentro de un
bucle este valor cambia, haciendo falsa la condición del ciclo y por lo
tanto indicará el fin del ciclo (el usuario puede determinar cuándo
hacerlo). La repetición controlada por centinela se considera como una
repetición indefinida (se desconoce el número de repeticiones).
1.1.5 Bandera
tomar sólo dos valores opuestos, generalmente: 1 (verdadero) o 0
(falso), a lo largo de la ejecución del algoritmo o programa. Es muy
utilizado en búsquedas.
J. Estructurade control repetitivamientras (while)
Al ejecutarse la instrucción mientras (while), se evaluará la expresión
booleana suministrada en los paréntesis (condición), y si su valor es
verdadero (distinto de cero) se realizará el ciclo o bucle (una o varias
instrucciones). Después, la condición es reevaluada y se procede de la
misma manera. Cuando la condición se vuelve falsa (es decir, cero), en
la siguiente evaluación se dará por terminado el ciclo mientras (while).
Si la condición nunca se vuelve cero, el ciclo nunca terminará y,
dependiendo de las instrucciones incluidas en el bucle, se generaría un
error de ejecución que detendría el programa, o podría ser que el

programa itere indefinidamente hasta ser detenido en forma manual.
En esta estructura no se conoce necesariamente el número de veces
que entrará al ciclo, ya que esto dependerá de la condición definida.
K. Estructurade control repetitivahacer_mientras (do while)
Esta estructura le permite al programador especificar que se repita una
acción en tanto cierta condición sea verdadera; cuando ésta es falsa se
sale del ciclo. La condición la revisa después del ciclo o bucle.
Es muy semejante al ciclo mientras, con la diferencia de que la
condición se evalúa después de ejecutar el cuerpo del bucle. Tanto el
ciclo mientras como el hacer_mientras pueden utilizarse cuando no se
conoce de antemano el número de veces que se repetirá el ciclo.
L. Estructurade control repetitivadesde (for)
El desde (for) es la estructura repetitiva más utilizada y simple de
manejar, ya que repite un conjunto de instrucciones un número
determinado de veces. Una de sus aplicaciones principales son los
arreglos.
XII. Funciones
La programación modular o funciones es una técnica que consiste en
dividir un programa en tareas y dar origen a la creación de pequeños
programas llamados módulos, subprogramas o subrutinas con la
finalidad de simplificar la elaboración y mantenimiento del mismo,
donde cada módulo se codifica y se procesa de manera independiente,
sin importar los detalles de otros módulos.
Las funciones son los bloques de construcción básicos de C. dentro de
ellas se da toda la actividad del programa.
Todo problema se puede resolver con funciones o sin ellas, pero su
uso adecuado hace que el programa sea más eficiente, fácil de leer y

probar.
M. Ventajas
 Facilita el diseño descendente.
 Los procedimientos dentro de ellas se pueden ejecutar varias
veces.
 Facilita la división de tareas.
 Se puede probar individualmente.
Las funciones pueden ser declaradas antes del main es decir fuera del
programa principal. Pero son llamadas dentro de este, la sintaxis para
declarar una función es la siguiente:
Tipo nombre_funcion (lista de parámetros) {
Lista de instrucciones;
}
N. Funciones sin paso de parámetros
Son aquellas que no reciben parámetros o valores, ya que éstos se
solicitan dentro de la función, luego se realizan las instrucciones
(cálculos u operaciones) y normalmente se imprime el resultado.
O. Funciones con paso de parámetros
Estas funciones son las más utilizadas en la programación ya que
pueden recibir uno o más valores llamados parámetros y regresan un
solo valor de tipo entero, real o carácter. Si deseas regresar un arreglo
de carácter es necesario hacerlo desde los parámetros. Los parámetros
o valores son enviados del programa principal o de otra función.
Dentro de la función se realizan solamente las instrucciones (cálculos u
operaciones).
P. Variables locales.
Se declaran dentro de la función y solo están disponibles durante su

ejecución.
Q. Variables globales.
Se declaran fuera de las funciones. Pueden ser utilizadas por todas las
funciones.
R. Transferenciade variables.
Por valor: copia el valor de la llamada en el parámetro formal de la
función.
Por referencia: se copia la dirección del argumento en el parámetro.

Manual laboratorio de programación i

Más contenido relacionado

La actualidad más candente (17)

Destacado (15)

Similar a Manual laboratorio de programación i (20)

Más de Estudiantes ISI_UCA (20)

Último (20)

Manual laboratorio de programación i