Manual de programacion

UNIVERSIDAD CENTROAMERICANA
Facultad de Ciencia, Tecnología y Ambiente
Ingeniería en sistemas de la información
Manual De laboratorio de programación I
Elaborado Por: Mario de Jesús Arce Díaz
Docente: Elsner Boanerge González Ortega
24 de junio de 2016

Contenido
Definición de algoritmo ............................................................................................................. 1
Identificadores.......................................................................................................................... 1
Comentarios ............................................................................................................................. 2
Tipos de datos En C/C++ ............................................................................................................ 2
Definición de variable................................................................................................................ 2
Tipos de variables...................................................................................................................... 3
Declaración de una variable en c++......................................................................................... 4
Como realizar las acciones de E/Sen C y C++............................................................................... 4
Constantes................................................................................................................................ 5
casting...................................................................................................................................... 5
Tipos de constantes............................................................................................................... 6
Declaración de una constante ................................................................................................ 6
Arreglos.................................................................................................................................... 7
Concepto.............................................................................................................................. 7
Arreglos unidimensionales..................................................................................................... 7
Concepto........................................................................................................................... 7
Declaración de un arreglo unidimensional........................................................................... 7
Inicialización de un arreglo ................................................................................................. 8
Arreglos bidimensionales........................................................................................................... 8
Estructuras de datos.................................................................................................................10
Printf y scanf............................................................................................................................12
Entrada de datos: función scanf() ..........................................................................................12
Salida de datos: función scanf().............................................................................................13
Entrada y salida sin formato......................................................................................................14
Manejo de ficheros en c............................................................................................................15
Creación de un archivo de acceso secuencial..........................................................................15
Creación de un archivo de acceso aleatorio................................................................................16
Estructura de control repetitiva o de iteración condicional .........................................................18
Implementación del ejemplo:................................................................................................20
Uso de bucles...........................................................................................................................20
Funciones ................................................................................................................................21
Uso de variables globales y locales ............................................................................................26

Variable local........................................................................................................................26
Variable Global.....................................................................................................................26
Bibliografía...............................................................................................................................28

Manual de laboratorio de programación I
Lenguajes de programación C/C++
1
Definición de algoritmo
Se denominaalgoritmoal conjuntode pasosordenadosyfinitosque permitenresolverun
problemaotarea específica.Losalgoritmossonindependientesdel lenguaje de programación yde
la computadoraque se vaya a emplearparaejecutarlo.
Identificadores
Un identificadoresuna secuencia de caracteres alfabéticos, numéricos y el guión bajo. Con ellos
podemos dar nombre a variables, constantes, tipos de dato, nombres de funciones o
procedimientos, etcétera.
Cada lenguaje de programación tiene sus propias características del tamaño del identificador; el
estándarde lenguaje Cnoespecifica un límite de tamaño para un identificador, pero para ciertas
implementaciones de C11 sólo los primeros 31 caracteres son significativos (ANSI C). El
programadortiene libertadparadarle cualquiernombre aun identificador,siguiendoestasreglas:
1. Debe resultar significativo, sugiriendo lo que representa.
2. No podrá coincidir con palabras reservadas, propias del lenguaje
3. Debe comenzar con una letra entre A y Z mayúscula o minúscula y no puede contener
espacios en blanco.
4. El lenguaje C distingue mayúsculas de minúsculas porque tienen diferente código ASCII.
5. Letras, dígitos y el carácter guion bajo están permitidos después del primer carácter.
6. No puedenexistirdosidentificadoresiguales,esdecir, dos elementos de un programa no
puedennombrarse de lamismaforma.Sin embargo,unidentificadorpuede aparecer más
de una vez en un programa.
7. No se puede utilizar una palabra reservada como identificador, sin embargo, los
identificadores estándar se pueden redefinir.
8. En lenguaje Cexistenidentificadores que podrían tener uno o varios puntos, tales como:
datos.nombrePersonal
Todo algoritmo debe ser:
Preciso: Debe tener
un orden entre los
pasos.
Finito en tamaño o
número de instrucciones,
debe terminar en algún
momento. Por lo tanto,
debe tener un punto
particular de inicio y fin.
Definido: Nodebe serambiguo
(dobles interpretaciones); si se
ejecuta el mismo algoritmo el
resultado
siempre será el mismo, sin
General: Debe
tolerar cambios que
se puedan presentar
en la definición del
problema.

2
Algunos identificadores que es preferible no utilizar:
A9, 1, Z, primer-nombre,estoporque el identificador debe representar claramente el dato que se
almacenaenla variable,ademásel ultimoidentificadornoesválidoporque el guion alto en c /c++
representa el signo de resta, no obstante pueden existir identificadores como ( i ) que son
utilizados como contadores dentro de un bucle.
Comentarios
Los comentariossontextosque nosonprocesadopor el compilador.Sirvencomoinformaciónal
programado.
Para que un textoseacomentariodebe estarentre lossímbolos/*(marcael inicio) y*/ (marca el
findel comentario)
Tipos de datos En C/C++
Los tipos de datos en C/C++ se clasifican en primitivos y derivados.
Los tipos de datos primitivos son losque estándefinidos
dentrodel lenguaje.
Los tipos de datos derivados se formana partir de los tipos
primitivos.
En C++ lostiposde datos numéricosenterossonlossiguientes:
Tipode Dato Descripción
Tipo de Dato Descripción Númerode bytes
típico
Rango
Int 2 -32768 a 32767
float (flotante) 4 3.4 E-38 a 3.4 +138
Long 8 1.7 E-308 a 1.7 +1308
char 1 -128 a 127
Con lostiposenterospuedenutilizarseloscalificadoressignedyunsigned.Estos calificadores
indicansi el númerotiene signoono.Si se usan solos,sinindicarel tipode datose asume int.
Definición de variable
Una variable esunobjetodel lenguaje cuyovalorse puede cambiar.Antesde utilizarunavariable
éstadebe de serdeclarada.Al declararuna variable,se le asociaunidentificador,esdecir,un
nombre,conun tipode almacenamientocuyaformadetermina lavisibilidadyexistenciade la
variable.

3
Tipos de variables
El tipode lavariable nosindicael conjuntode valoresque puede tomarylasoperacionesque
puedenrealizarseconella.Existencincotiposde datosbásicosenC:
Tipo de
dato
Descripción Memoria
Int Cantidad entera 2 bytes o una palabra (varía
según el (compilador).
Char Carácter 1 byte.
Float Almacena valores reales en punto flotante. 1 palabra (4 bytes).
Double Almacena valores reales en doble precisión. 2 palabras (8 bytes).
Void Se utiliza para definir una función que no devuelve
ningún valor o declarar punteros genéricos (lo
veremos más tarde).
Estos tiposbásicos a excepciónde void admitenunamodificacióndelrangode valores,aplicando
lassiguientespalabras reservadas:
 Short (corto)
 Long (largo)
 Signed(consigno)
 Unsigned(sinsigno)
Veamoslossiguientesejemplos:
Tipo Tamaño en bits Rango
Char 8 -127 a 127
Unsignedchar 8 0 a 255
Signedchar 8 -127 a 127
Int 16 -32767 a 32767
Unsignedint 16 0 a 65535
Signedint 16 -32767 a 32767
Shor int 16 -32767 a 32767
Unsignedshort int 16 0 a 65535
Signedshort int 16 -32767 a 32767
Long int 32 -2147483647 a 2147483647
Signedlong int 32 -2147483647 a 2147483647
Unsignedlongint 32 0 a 4294967295
Float 32 Seis dígitos de precisión
double 64 Diez dígitos de precisión
Long double 64 Diez dígitos de precisión

4
Declaración de una variable en c++
Para Declarar unavariable enc++ debemostomarencuentaque necesitamosincluirlibreríasylas
palabrasreservadasde c con usingnamespace std primerose digitael tipode variable,luegose
escribe el identificadorsi se desease puede inicializarconunigual y su valorluegose finalizacon
puntoy coma. Veamosunejemplo:
#include<iostream>
usingnamespace std;
intmain()
{
int a,b,c; //Declaraciónde variablesenteras.
floatn,m,o;//Declaraciónde variablesrealesodecimales.
char x,y,z; //Declaraciónde variablestipocarácter.
char cadena[12];//Declaraciónde variablescadena.
return0;
}
Nota: Comopodemosobservar en el ejemplo las variables de tipo cadena son un arreglo de tipo
carácter y el limite lodefineel programadorsiguiendolaestructura:identificador [núm de caráct]
debemosde tenersiempre encuentaque nohayque desperdiciarespaciosde memoriaesdecirsi
conocemos el tamaño al que podría llegar la variable no lo excedamos.
Como realizar las acciones de E/S en C y C++
Para realizar las acciones de entrada y salida se tiene que tomar en cuenta algunos factores que
inciden en esta acción como las palabras reservadas de los lenguajes como por ejemplo scanf y
printf palabras propias del lenguaje c para profundizar un poco más analicemos los siguientes
ejemplos:
Algortmo en el lenguaje C Algoritmo en el lenguaje C++
#include<stdio.h>
#include<conio.h>
int main ()
{
int num;
printf ("n Digite un número");
scanf ("%d", &num);
}
#include <iostream>
using namespace std;
int main()
{
int x;
x=0;
cout << "Digite un numero" << endl;
cin >>x;
return 0;
}

5
En C++ using namespace std; funciona para poder utilizar las palabras reservadas de C.
Constantes
Una constante es un dato que permanece sin cambio durante el desarrollo del algoritmo o
durante la ejecución del programa, es decir valores fijos que no pueden ser alterados por el
usuario.La mayoría de loslenguajesde programación permiten el manejo de diferentes tipos de
constantes; éstas pueden ser enteras, reales, caracteres y cadenas.
casting
consiste enalmacenarundato de una variable enotradiferente,aunque para esto se debe tomar
encuenta que estonose puede hacercontodos lostipos de datos ejemplo de esto tenemos que
no se puede realizar un casting entre una variable de tipo char con una de tipo entero porque
posee datos muy diferentes.
Para ejemplificar esta acción observemos el siguiente algoritmo:
#include <iostream>
int main()
{
signed long ls=+1230000;
short lu=125;
//castin
cout<<"Resultado del cambio"<<endl;
ls=(signed long)lu;
cout<<ls;
return 0;
}
En este castingla variable (ls) tomael valorde lavariable (lu) y se imprime en pantalla el numero
125.

6
Tipos de constantes
Tipos de
constante
Descripción y ejemplos
Enteras Son una sucesión de dígitos precedidos o no por el signo 1 o 2 dentro de un
rango determinado. Ejemplos: 234, 2456, etcétera.
Reales Son una sucesión de dígitos con punto adelante, al final o en medio y seguidos
opcionalmente de un exponente. Ejemplos: 82.347, 0.63, 32.4e205, 7.4e03
Carácter Un constante carácter (char) es un carácter del código ASCII encerrado entre
apóstrofos. Ejemplos: ‘a’, ‘b’, ‘c’
cadenas Una constante cadena es una secuencia de caracteres encerrados entre dobles
comillas. Ejemplos: “123”, “26 de noviembre de 1974”, “Esto es una cadena”
Declaración de una constante
En lenguaje C++una constante se define por mediode lapalabraconst:
const float iden_variab = valor;
para ejemplificarestose mostraráun ejemploque consiste enunalgoritmoque calcule el áreadel
círculo:
#include <iostream>
//Declaración de constantes
const float pi=3.1416;
int main ()
{
//declaración de variables
float radio,area;
//inicialización de variables
radio=0.0;
area=0.0;
cout<<"Digite el valor del radio del circulo"<<endl;
cin>>radio;
area=pi*(radio*radio);
cout<<"El area del circulo es de: "<<area; }

7
Arreglos
Concepto
Un arreglo es un tipo de dato estructurado que almacena en una sola variable un conjunto
limitado de datos o elementos del mismo tipo. Asimismo, es un conjunto de localidades de
memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección
más altaal último.Porsí mismo,el nombre del arregloapunta a la dirección del primer elemento
del arreglo.
Para accedera unelementoalmacenadoenunarreglose especificael identificadorde lavariable
mas el índice entre corchete: indent[índice].
Arreglo[4]:
Un arreglose caracterizapor:
1. Ser una listade un númerofinitode nelementosdelmismotipo.
2. Almacenarloselementosdel arregloenmemoriacontigua.
Cuandodecimosmemoriacontiguanosreferimosaque el espaciode memoriaque se reservaes
unotras otroes decirseguido
3. Tenerun úniconombre de variable que representaatodosloselementosyéstosse diferencian
por un índice o subíndice.
Los arreglos se clasificanen:
1. Unidimensionales(vectoresolistas)
2. Bidimensionales(tablasomatrices)
3. Multidimensionales(másde dosdimensiones)
Los más utilizadossonlosunidimensionalesylosbidimensionales
Arreglos unidimensionales
Concepto
Un arreglounidimensional esunconjuntode nelementosdelmismotipoalmacenadosen
memoriacontinuaenunvectoro lista.Para accedera cada elementodel arreglose requiere de un
soloíndice o subíndice,el cual representalaposiciónenlaque se encuentra.
Declaración de un arreglo unidimensional
Para declararuna enc/c++ se debe especificarel tiposeguidode el identificador y entre corchete
[] la cantidad de elementos del arreglo para esto podemos utilizar la siguiente declaración:
0 1 2 3

8
Tipo_de_dato identificador [tam_arreglo];
Donde:
tipo_dato: se refiere al tipo de dato de cada elemento del arreglo; puede ser entero, real,
carácter, etcétera.
Identificador: es el nombre que representa a todo el arreglo
tam_arreglo: es la cantidad de elementos que contiene el arreglo.
Inicialización de un arreglo
Existentres formas de inicializarun arreglo:
1. Inicializarel arreglodonde lodefinimosencero
a. intarreglo1[5]={0};
2. Inicializarel arreglodonde lodefinimos,perocon valoresdiferentes
a. intarreglo2[3]={0,1,2};
3. inicializarel arreglo de forma independiente
a. intarreglo3[3];
arreglo3[0]=1;
arreglo3[1]=2;
arreglo3[2]=3;
arreglo3[3]=4;
A continuación,se muestraunarreglode númerosrealescuyoidentificadores a:
Lenguaje c
Int a[5];
Arreglos bidimensionales
Según (corona & Acona, 2011) en su libro Diseñode algoritmosysu codificaciónen lenguaje C
afirman que un arreglo bidimensional es un conjunto de n elementos del mismo tipo
almacenados en memoria contigua en una matriz o tabla. A diferencia de los arreglos
unidimensionalesque sólorequierende unsubíndice,losarreglosbidimensionales para acceder a
cada elemento del arreglo requieren de dos índices o subíndices declarados en dos pares de
1 2 2 4 5
a[0] a[0] a[0] a[0] a[0]
Elemento
s
Posiciones

9
corchetes, donde el primer corchete se refiere al tamaño de filas y el segundo al tamaño de
columnas.
Tambiéndebemos tomar en cuenta cómo podemos declarar dicho arreglo que es de esta forma:
Int arreglo [4] [3]
Donde:
int representa el tipo de arreglo
Arreglo: Este es el identificador
[4]: representa el número de filas de nuestro arreglo también considerado una matriz
[3]: Determina el número de columnas que poseerá nuestro arreglo bidimensional
Para poder llamar a un arreglo de este tipo o simplemente mandar a imprimir debemos
especificar el identificador más su posición a través de los índices.
Para poder hacer uso del dato en la última posición del arreglo que se muestra en rojo lo
debemos hacer de la siguiente forma:
Arreglo 3 2
Ahora nos preguntaremos y porque 3,2 y no 4,3 como podemos visualizar el arreglo
bidimensional al igual que el unidimensional empiezan en la posición 0 por esa razón el
último elemento se encuentra en la posición i-1 para ambos índices
0 1
20
1
2
Primer índice
Segundo índice
0 1
20
1
2
Primer índice
Segundo índice

10
Para verlo de forma más clara realizamos un ejemplo en el cual solo declararemos un
arreglo bidimensional
Estructuras de datos
Una estructura define unaplantillaconlaque posteriormentese puede declararunavariable. Una
de las característicasde lasestructurasesque hay que definirlasantesde usarlasen ladeclaración
de variables.En la definiciónno se declara ni reservando memoria para ninguna variable, sólo se
construye una estructura con determinadas características, para después poder declarar una
variable de ese tipo. Aunque también se puede definir la estructura y declarar variables del tipo
estructura definida, lo normal es declararlas fuera de la definición. Más adelante se muestra la
forma de declarar una estructura, un tipo de dato y una variable tipo registro (struct).
Para crear una estructurase empiezapordefinirsutipoparaellorealizamosunaacciónsimilarala
de definiciónde unavariable,paraestose utilizalapalabrareservada struct normalmenteseguida
por un nombre y llave izquierda; después se define el tipo y nombre para uno o más campos.
Observemos la forma más común de declarar una estructura:
struct empleado
{
char nombre[35];
int edad;
char sexo;
double sal;
};
En este arreglo se ha definido el tipo de dato empleado; pero si nos damos cuenta aún no
existe ninguna variable asociada a este nuevo tipo de dato por lo que declararemos la
variable reg con este tipo de dato:
struct empleado reg;
ahora lo implementaremos en un algoritmo que tiene como tarea registrar algunos datos
como el nombre, sexo, edad y mostrar los datos en pantalla.
#include <iostream>
#include <stdlib.h>
struct empleado
{

11
char nombre[35];
int edad
char sexo;
double sal;
};
int main()
{
struct empleado reg;
cout << "Digite los datos del empleados"<< endl;
cout<<"Escribia los nombres del empleado"<< endl;
cin.getline(reg.nombre, 35);
cout<<"Digite la edad"<< endl;
cin>>reg.edad;
cout<<"Escriba F - femenino o M masculino"<< endl;
cout<<"para indicar el genero"<< endl;
cin>>reg.sexo;
cout<<"Digite el salario por hora del empleado"<< endl;
cin>>reg.sal;
system("cls");
cout<<"DATOS DEL EMPLEADOnn";
cout<<"Nombre: "<<reg.nombre;
cout<<"nEdad: "<<reg.edad;
cout<<"nSexo: "<<reg.sexo;
cout<<"nsalario: "<<reg.sal<<endl<<endl;
system("pause");
return 0;
}

12
Existen dos formas de declarar una variable de tipo empleado:
struct empleado reg y escribiendo el identificador fuera de las llave de la estructura como
se muestra en el siguiente ejemplo:
struct empleado
{
char nombre[35];
int edad
char sexo;
double sal;
}registrosDat;
Donde registroDat es la variable de tipo empleado.
Printf y scanf
El lenguaje Cnotiene palabras reservadasparalae/sestándardel sistema(tecladoypantalla).
Estas operacionesse realizanmediante funcionesde bibliotecaque encontramosenel archivode
cabecerastdio.h(standardinput-outputheader).Lae/sconformatose realizapormediode las
funcionesscanf() yprintf.Lasf de scanf() y de printf() significan“conformato”.
Entrada de datos: función scanf()
La función scanf() se usa para la entrada y nos permite leer (introducir) datos desde el teclado y
asignarlos a variables de C, de acuerdo con el formato especificado.
Sintaxis: scanf (“cadena de control”, argumento1, argumento2 …);
La cadenade control tiene unoo variosespecificadoresocódigosde formatoque haránreferencia
al tipode dato de losargumentosy,si se desea,suanchura.Los códigosestarán precedidos por el
carácter % seguido de un carácter de conversión. La cadena de control deberá escribirse entre
comillas (“ ”).
La lista de argumentos serán las variables; scanf necesita saber la posición de memoria de la
computadoraenque se encuentralavariable parapoderalmacenarlainformaciónobtenida, para
elloutilizaremosel símboloampersand(&),que colocaremos antes del nombre de cada variable.
Por lotanto,el & sirve para apuntar a la dirección de memoria de dicha variable. A continuación,
presentamos varios ejemplos.
Cuando realizamos una lectura a través de scanf de una cadena no es necesario utilizar el
ampersand veamos el siguiente ejemplo:
Char nombre[10];

13
scanf( “%s”,nombre); o scanf( “%s”,&nombre);
El scanf (“%f %d %c”, &x, &y, &z); almacena en x, m y z, respectivamente, los datos introducidos
de cualquiera
de las siguientes formas:
• Oprimir la tecla <enter> después de introducir cada dato.
• Oprimir la tecla <tab> después de introducir cada dato.
• Oprimir un espacio en blanco después de introducir cada dato.
• Alternar cualquiera de las opciones anteriores entre cada dato.
A continuación, veremos una tabla con los distintos formatos y tipos de datos en el lenguaje C
Entero Decimal Int %d,%i 232768 a 32767 (2 bytes)
Real (punto flotante) Float %f, %g, %G, %e, %E 3.4E238 a 3.4E138
Carácter con signo Signed char %c -128 a 127
Real Double %lf, %lg, %lG, %le, %lE
Real Long doublé %lf, %lg, %lG, %e, %lE 3.37E24932 a
1.18E14932
Entero largo decimal Long int %ld 22147483648 a
2147483647
Salida de datos: función scanf()
printf (cadenade control de formato,otrosargumentos);
la cadenade control de formatodescribe el formatode salida y, otros argumentos (los cuales son
opcionales) correspondenacada especificaciónde conversiónde lacadenade control de formato.
Cada especificación de conversión comienza con un signo de porcentaje que termina con un
especificadorde conversión.Puede haber muchas especificaciones de conversión en una cadena
de control de formato.
Algunascosasque debemostomarencuentaesno olvidarcerrar losparéntesis, por presentación
debemoseditarclaraslassalidasde unprograma,para que sean máslegiblesypoderdisminuirlos
errores de los usuarios.
La cadena de control debe escribirse entre comillas (“ ”) y puede tener al menos uno de los tres
elementos
siguientes:
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 formato (indica de qué tipo de dato se trata).
Al igual que enla sentenciascanf unespecificadorocódigode formatose iniciaconun carácter %
y terminaconun carácter de conversión;porejemplo,enel formato%slaletraese (s) esel
carácter de conversión paraimprimircadenas.Debe haberel mismonúmerode códigosde
formatoque de argumentos y cada unode éstosdebe tenerunorden.Encaso contrarioel
resultadonoserácorrecto.

14
Los argumentospuedenservariables,constantes,oengeneral expresionesde salida.Para
imprimirlas letrasXYZenla pantalla,podríahacerse de las siguientesformas:
• printf (“XYZ”);//Lalistade argumentosesopcional.
• printf (“%s”,“XYZ”);//El formato% s imprime el texto“XYZ”comocadenade caracteres.
• printf(“%c%c%c”,’ X ’ , ’ Y ’ , ’ Z ’ ); //Losapóstrofosque encierrancada letrase empleanpara
designarconstantesde caracteres.El formato%c imprime el valorcomouncarácter.
Los códigosde formatopuedencontrolaraspectosde laaparienciade losdatos:la longitud,el
númerode decimalesylajustificaciónaizquierdaoderecha.
Sintaxis:%[signo] [longitud] [.precisión] [l/L] Carácterde Conversión
Los valoresentre [ ] son opcionales,donde:
signo: indicasi el valorapareceráa la izquierda(signomenos),oa laderecha(pordefecto).
longitud:longitudmáximadel valorque apareceráenlapantalla.
precisión:indicael númeromáximode decimalesque tendráel valor.
l/L: utilizamosl cuandose trata de unavariable de tipolong,yL cuandoes de tipodouble.
El códigode formato%4d indicaque imprimiremosunnúmeroentero encuatroposicioneso
lugares.
Entrada y salida sin formato
Las funcionesprincipalesque realizanlaentradaysalidasinformatoson:
 getche() Lee uncarácter del teclado,nohayque esperarhastaque se pulse latecla<enter>.
Visualizael ecodel carácter.
 getchar() Lee uncarácter del teclado,esperahastaque se pulsala tecla<enter>.
 getch() Lee uncarácter del teclado,nohay que esperarque se pulse latecla<enter>.No
visualizael ecodel carácter.
 putchar() Imprime uncarácter enla pantallaenlaposiciónactual del cursor.
 gets() Lee unacadenade caracteresintroducidaporel teclado.
 puts() Imprime unacadenaenlapantalla,seguidade uncarácter de saltode línea.
 justificandoaladerecha.El rellenoesblanco.
Ejemplos
#include <stdio.h>
#include <conio.h>
main()
{
char c;

15
puts(“Dame uncarácter: “); fflush(stdin);
c=getche();//Lee uncarácterdel teclado
putchar(c);//Loimprime enlapantalla
puts(“Dame otrocarácter: “); fflush(stdout);
c=getchar();//Lee uncarácter del teclado,esperahastaque se pulse latecla<enter>
puts(“Dame otrocarácter: “); fflush(stdin);
c=getch();//Lee uncarácter del teclado
getch();return0;
}
Manejo de ficheros en c
La biblioteca estándar proporciona muchas funciones para leer datos desde archivos y para
escribirdatos enarchivos.La funciónfgetc,al igual que getchar, lee un carácter desde un archivo.
La función fgetcrecibe como argumento un apuntador FILE para el archivo desde el que se lee el
carácter. La llamadaa fgetc( stdin ) lee un carácter desde stdin, la entrada estándar. Esta llamada
esequivalente alallamadabagetchar().Lafunciónfputc, al igual que putchar, escribe un carácter
enun archivo. La función fputcrecibe comoargumentosuncarácter a escribiryunapuntadorpara
el archivo en el cual se escribirá el carácter. La llamada a la función fputc( ‘a’, stdout ) escribe el
carácter ‘a’ en stdout, la salida estándar.nEsta llamada es equivalente a putchar( ‘a’ ).
Muchas otras funciones para leer datos desde la entrada estándar y escribir datos hacia la salida
estándar tienen funciones similares de procesamiento de archivos. Por ejemplo, las funciones
fgetsy fputs pueden utilizarseparaleerunalínea desde un archivo y para escribir una línea en un
archivo, respectivamente. La salida estándar. En las siguientes secciones, presentamos los
equivalentesparael procesamientode archivos de scanf yprintf,fscanf y fprintf. Más adelante en
este capítulo, explicaremos las funciones fread y fwrite.
Creación de un archivo de acceso secuencial
C no impone una estructura a un archivo. Por lo tanto, las ideas de registro de un archivo no
existencomoparte del lenguaje C.Entonces, el programador debe proporcionar la estructura del
archivo para cumplir con los requerimientos de una aplicación en particular. En el siguiente
ejemplo, mostraremoscómoel programadorpuede insertar una estructura de registro dentro de
un archivo.

16
Ejemplo: Algoritmo para realizar registros de herramientas
Creación de un archivo de acceso aleatorio
La función fwrite transfiere un número específico de bytes que comienzan en una ubicación
específica de la memoria hacia un archivo. Los datos se escriben al principio de la ubicación del
archivo indicada por la posición del apuntador. La función fread transfiere un número específico
de bytes desde la ubicación especificada en el archivo por medio del apuntador de posición del
archivo,haciaun área enmemoria que comienza con la dirección especificada. Ahora, cuando se
escribe un entero, en lugar de utilizar
fprintf( ptrF, “%d”, numero );
#include <stdio.h>
int main()
{
int numCta;
char nombreHerram[30];
int cantidad;
double precio;
FILE *ptrHerram;
if((ptrHerram=fopen("herram.dat","w"))==NULL){
printf("nNose pudo abrir el archivon");
}else{
do{
printf("Ingrese la siguiente informacion:""nNumerode registronNombre de la
herramienta""nCantidadnPrecion?: ");
scanf("%d%s%d%lf",&numCta,nombreHerram,&cantidad,&precio);
fprintf(ptrHerram,"%d%s %d %.2fn",numCta,nombreHerram,
cantidad,precio);
}while(!feof(stdin));
fclose(ptrHerram);
}//fin de else
return 0;
}

17
Lo que podría imprimir un solo dígito o hasta 11 (10 dígitos más un signo, cada uno de los cuales
requiere 1 byte de almacenamiento) para un entero de 4 bytes, puede utilizarse
fwrite( &numero, sizeof( int ), 1, ptrF );
Lo que siempre escribe 4 bytes (o 2 bytes en un sistema con enteros de 2 bytes) desde una
variable numerohaciael archivorepresentadoporptrF(másadelante explicaremos el argumento
1). Posteriormente,freadpuedeutilizarse para leer 4 de estos bytes dentro de la variable entera
numero.Aunque freadyfwrite leenyescribendatos,talescomoenteros, de tamaño fijo en lugar
de formatos de tamaño variable, los datos que manipulan se procesan en el formato fuente la
computadora (es decir, bytes o datos), en lugar del formato de
printf y scanf legible para el humano.
Ejemplo: programa para inicializar una estructura y crear un fichero
#include <stdio.h>
//definiciondela estructura DatosCliente
struct DatosCliente{
int numCta;
char apellido[15];
char nombre[10];
double saldo;
};
int main()
{
//crea DatosClientecon informacionen blanco
struct DatosCliente clienteEnBlanco={0,"","",0.0};
FILE*ptrCf;
//fopen abreel archivo
if((ptrCf=fopen("credito.dat","wb"))==NULL){
printf("nEl archivo nopudoabrirse");
}else{
//inicializa el archivo con 100 registros en blanco
for(int i=1; i<=100; i++){
fwrite(&clienteEnBlanco,sizeof(struct DatosCliente),1,ptrCf);
}//fin de for
fclose(ptrCf); //cierra elarchivo
printf("nSe inicializo el archivocon100registros enblancon");
}//fin de else
return 0;
}

18
Estructura de control repetitiva o de iteración condicional
Las computadoras están diseñadas primordialmente para aquellas aplicaciones en las
cuales una operación o conjunto de ellas deben repetirse más de una vez.
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. En cada vuelta del ciclo comprueba si la condición es
verdadera, rompiéndose el ciclo cuando es falsa. La condición en algún momento tiene
que ser falsa ya que en caso contrario el bucle se hará infinito.
Ejemplo: Calculo de número mayor menor y el promedio
#include <iostream>
#include <stdlib.h>
int main ()
{
int a,b,c;
float prom;
prom=0.0;
a=0;
b=0;
c=0;
cout<<"Digiteelprimer numero"<<endl;
cin>>a;
cout<<"Digiteelsegundo numero"<<endl;
cin>>b;
cout<<"Digiteeltercer numero"<<endl;
cin>>c;
system("pause");
system("cls");

19
system("cls");
if (a>=b && a>=c)
{
cout<<"El mayor es: "<<a;
}
else if (b>=a &&b>=c)
{
cout<<"El mayor es: "<<b;
}
else if (c>=a &&c>=b)
{
cout<<"El mayor es: "<<c;
}
if (a<=b && a<=c)
{
cout<<"nEl menor es: "<<a;
}
else if (b<=a &&b<=c)
{
cout<<"nEl menor es: "<<b;
}
else if (c<=a &&c<=b)
{
cout<<"nEl menor es: "<<c;
}
prom=(a+b+c)/3;
cout<<"nEl promedioes: "<<prom<<endl;
}

20
Implementación del ejemplo:
Uso de bucles
while(condicion)//MIENTRAS LA CONDICION NO SE CUMPLA REALIZA LAS ACCIONES DEFINIDAS
{
Accion 1 a realizar
Accion 2 a realizar
Accion 3 a realizar
}
for (sumador=0; sumador<=valorLimite;sumador++)//SE INICIALIZA EN 0 EL SUMADOR
{ //Y HASTA QUE SEA <= A VALOR DE 1 EN 1 HACER
Accion 1 a realizar
Accion 2 a realizar
Accion 3 a realizar
}

21
do
{
Accion 1 a realizar
Accion 2 a realizar
Accion 3 a realizar
}while (condición); //ES SIMILAR ALWHILE PERO ESTE PERMITE REALIZAR UNA VES LA SENTENCIA DE
ACCIONES
Funciones
Las funcionespermitenalosusuariosdividirun programa en módulos. Aplicando el termino muy
famosoenprogramacióndivide yvencerásesdecir es más fácil dividir el problema en problemas
pequeñosyasí podersolucionarlosde maneraindependienteconel objetivosé que estasacciones
aporten a un problema macro esto también esto esta denominado en la programación
descendente.Todaslasvariablesque se definenenuna función son variables locales, es decir, se
conocen sólo en la función en la que se definen. La mayoría de las funciones tiene una lista de
parámetros.Losparámetrosproporcionanlosmediosparatransferirinformaciónentre funciones.
Los parámetros de una función también son variables locales de dicha función.
¿Cómo crear una función?
Tipo de función nombre de la función (tipo de variable parámetros);
Cunadohablamosde unafunciónhablamosde dosaccionesmuyimportantescrear e invocar para
entender un poco más esto veremos las siguientes ilustraciones:
Como crear una función
Tipo de función nombre de la función (tipo de variable parámetros);
{
Lista de acciones;
Lista de acciones;
}
¿Cómo invocar una función?
nombre de la función (parámetros);

22
Comose mencionabaanteriormente esnecesario definir el tipo de parámetro que se le pasan a l
función (por valor o por referencia);
Si es por referencia esta es la forma:
Tipo de función nombre de la función (&primer_parametro);
Por valor solo se escribe el identificador de la variable sin el &.
Veamos los siguientes ejemplos:
Durante la programaciónenC/C++ lograremosidentificar6 funcione básicasdentrodel manejode
ficherosenCentre los cuales tenemos: Crear, registrar, Modificar, visualizar, modificar, eliminar
Paso por referencia
Crear un fichero
Registrar
información

23
Visualizar la
información
Buscar un
registro

24
Modificar un
registro

25
Eliminar un
registro

26
Uso de variables globales y locales
Definición
Variable local
Una variable local es aquella cuyo ámbito se restringe a la función que la ha declarado se dice
entonces que la variable es local a esa función. Esto implica que esa variable sólo va a poder ser
manipulada en dicha sección, y no se podrá hacer referencia fuera de dicha sección. Cualquier
variable que se defina dentro de las llaves del cuerpo de una función se interpreta como una
variable local a esa función.
Variable Global
Una variable global esaquellaque se define fueradel cuerpo de cualquier función, normalmente
al principiodel programa,después de la definición de los archivos de biblioteca (#include), de la
definiciónde constantessimbólicasyantesde cualquierfunción. El ámbito de una variable global
son todas las funciones que componen el programa, cualquier función puede acceder a dichas
variables para leer y escribir en ellas. Es decir, se puede hacer referencia a su dirección de
memoria en cualquier parte del programa.
Como podemos observar la variable se encuentra antes de la función principal por lo que
se considera de ámbito global y puede ser utilizada por cualquier otra función que este
debajo del main.
Variable global
Variables locales

27
Como se los mencionaba anteriormente en el concepto las variables locales solo pueden
ser utilizada dentro de la función esto representa que si declaramos en dos funciones
diferentes la misma variable no habrá ningún problema algo sucede con las variables
globales porque si se define un variable global y otra igual es definida es definida como
variable local se provoca un error porque el compilador toma la última declaración como
una redefinición y lo que causa un conflicto y se tiene que eliminar o redefinir
inmediatamente.
Conclusiones
Considero que la elaboración de este manual contribuyó al desarrollo de mis habilidades
dentro de la programación, facilita el aprendizaje dentro de la asignatura porque permite
que nosotros como estudiantes podamos poner en práctica lo aprendido dentro de las
cesiones de clase impartidas en laboratorio de programación I, además representa una
documentación de la clase que podrá me podrá servir en el futuro porque representa las
bases de la programación e C/C++
La realización de este manual es envase al libro Diseño de algoritmos y su codificación en
lenguaje C de (corona & Acona, 2011), haciendo uso de conceptos o teoría para la debida
documentación.

28
Bibliografía
corona, M., & Acona,M. (2011). Diseño de algoritmosy su codificación en lenguajeC. México,D.F:
McGRAW-HILL.

Manual de programacion

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Manual de programacion

Más de Estudiantes ISI_UCA

Último

Manual de programacion