Programacion II Unidad, 1,2,3

ingeniería de sistemas (Universidad Nacional Experimental Politécnica de la Fuerza Armada

Bolivariana)

Studocu no está patrocinado ni avalado por ningún colegio o universidad.

Descargado por britney bonaldy (bricamacho92@gmail.com)
 República Bolivariana De Venezuela
Ministerio Del Poder Popular Para La
Defensa
Universidad Nacional Experimental De La Fuerza
Armada UNEFA-NUCLEO-BARINAS

PROGRAMACION
II

Ingeniería de Sistemas
Profesora: Jorge Zamudio

1
Descargado por britney bonaldy (bricamacho92@gmail.com)
 Barinas enero de 2021

INDICE
INTRODUCCION............................................................................................................................ 3

1. CARACTERISTICAS DE LENGUAJE DE PROGRAMACION ESTRUCTURADA.......5

1.1 CONSTANTES Y MACRO....................................................................................................5
1.2 PRE PROCESADORES: UTILIZACION DE DIRECTIVAS...........................................5
1.3 COMPILACION CONDICIONAL: LIBRERÍA..................................................................6
1.4 ARCHIVOS. OBJETIVOS Y ARCHIVOS EJECUTABLES.............................................6
1.5 EJERCICIOS............................................................................................................................6
2. ORDENAMIENTO Y BUSQUEDA.........................................................................................9
2.1 BURBUJA, SELECCIÓN, INSERCION, QUICK SORT, SORT MERGE, HASHING. .10
2.2 EJERCICIOS.............................................................................................................................12

3. UTILIZACION AVANZADA DE ARCHIVOS........................................................................15

3.1 ARCHIVO DE ENTRADA Y SALIDA...................................................................................15
3.2 DESCRIPTORES DE ARCHIVOS.........................................................................................20
3.3 EJERCICIOS..............................................................................................................................24

CONCLUSION.................................................................................................................................26

Descargado por britney bonaldy (bricamacho92@gmail.com)

 INTRODUCCIÓN

Un lenguaje de programación es una herramienta que nos permite elaborar programas (ficheros
ejecutables) de forma más o menos fácil. Los procesadores tan solo son capaces de ejecutar
instrucciones muy sencillas, tales como la suma de dos números, mover un valor del procesador
a la memoria, etc. Además, para entender este tipo de instrucciones, el procesador debe
recibirlas codificadas en sistema binario, es decir, como secuencia de unos y ceros. Para
entendernos, si el procesador recibe un 1000 0111,

Aunque se podría crear un programa simplemente escribiendo los cientos de millones de unos y
ceros que representan las órdenes del procesador (y en los años sesenta, con los primeros
ordenadores, así se hacía), este sistema resulta muy complicado. Por ese motivo, se decidió
simplificar un poco la tarea y se crearon los lenguajes de programación. Estos lenguajes son
simplemente programas que traducen las órdenes que nosotros les escribimos siguiendo unas
reglas sintácticas (por eso se llaman lenguajes) al idioma de unos y ceros, el único que el
procesador es capaz de entender. Según lo cerca o lo lejos que esté el lenguaje de programación
del idioma binario del ordenador, se clasifica en tres grupos:

• Lenguajes de bajo nivel. El lenguaje de bajo nivel por excelencia es el ensamblador.

Este lenguaje es simplemente una traducción directa de cada orden del procesador a una
palabra que explique qué hace esa orden (la palabra, evidentemente, está en inglés). En el
ejemplo anterior, en vez de escribir 1000 0111, escribiríamos ADD (suma en inglés). No
facilita mucho las cosas, porque sigue siendo necesario escribir muchísimas órdenes para
elaborar programas muy simples, pero ayuda porque es más sencillo recordar que para sumar
hay que escribir ADD que acordarse de escribir 1000 0111.

• Lenguajes de alto nivel. Los lenguajes de alto nivel, entre los que se encuentra el C, son
la base de la programación. En estos lenguajes, en vez de escribir ADD, por ejemplo, podemos
escribir instrucciones del tipo “C=A+B” (es decir, C es igual a la suma de A más B), mucho
más cercanas a nuestro idioma natural. Existen muchísimos lenguajes de alto nivel: Basic,
Pascal, Fortran, Cobol, C… pero todos son muy parecidos, de forma que una vez aprendido
uno, es muy fácil aprender el resto. Además, C es uno de los más usados en el mundo (por no
decir el que más).

• Lenguajes orientados a objetos. Estos lenguajes son de nivel todavía más alto que
los anteriores, aunque se basan en ellos (por ejemplo C++ y Java, dos de los más comunes,
son extensiones de C). Al contrario de lo que ocurre con los lenguajes de alto nivel y el
ensamblador, no es posible aprender un lenguaje orientado a objetos sin conocer antes un
lenguaje de alto nivel. El objetivo de los lenguajes orientados a objetos es, sobre todo, crear
programas, no desde cero, sino juntando piezas programadas por otras personas.

El lenguaje C. Se trata seguramente del lenguaje de programación de alto nivel más

usado en el mundo. Su origen se remonta a los años 1969-1973, cuando Dennis Ritchie

Descargado por britney bonaldy (bricamacho92@gmail.com)

generó un nuevo lenguaje a partir del lenguaje “B” creado por Ken Thompson.
Lógicamente, lo llamó C.

En 1978, Ritchie y Brian Kernighan publicaron el primer libro de

C (The C Programming Language) y, a partir ese momento, C se convirtió en un
referente de la programación. Actualmente, existen muchas pequeñas variantes. Son
tantas que se ha creado un estándar, el ANSI C, compatible con prácticamente todos los
compiladores de C.

La parte de C incluida en C++ es conocida como C‐ y puede compilarse en C++ sin ningún
problema. La sintaxis y las reglas de edición en general son iguales, por lo que a las
modificaciones introducidas por C++ a la edición de código procedural (es decir, como si se
tratase de C) se las denomina modificaciones menores ya que son fácilmente asumibles por un
programador de C. A las modificaciones introducidas para soportar la programación orientada a
objetos y la programación genérica, se las denomina modificaciones mayores, puesto que
requieren para su uso de un cambio radical en la filosofía de programación.

Descargado por britney bonaldy (bricamacho92@gmail.com)

 CARACTERISTICAS DE LENGUAJE DE PROGRAMACION
ESTRUCTURADA CONSTANTES Y MACROS
Para definir constantes se sigue el formato:
#define identificador valor
El compilador substituirá el identificador por el valor, cuando lo encuentre en el archivo fuente. En
general, las constantes se escriben totalmente en mayúsculas, aunque el preprocesador no impone
ninguna norma al respecto.
Es sólo por claridad.
Permite también definir macros, en las cuales se sustituye sus parámetros por los del punto en que
se la invoca.
Ejemplos:
#define TRUE 1
#define FALSE 0
#define ERROR_MSG “Error en la lectura\n”
#define IMPRIMIR(x) printf (“%d “, x)

PRE PROCESADORES
El preprocesador es una parte del compilador que realiza una transformación del código fuente
antes de pasar a la compilación propiamente dicha. El preprocesador es el encargado de la
inclusión de ficheros, compilación condicional y definición y expansión de macros. Para indicarle
al preprocesador la realización de estas tareas este posee un lenguaje propio. Las directivas del
preprocesador comienzan siempre con el símbolo # y emplean toda la línea en la que se utilizan.
A continuación se tiene una tabla con las directivas del preprocesador junto a una breve descripción.

Directiva Descripción
#include Inclusión de ficheros.
#define Definición de macros.
#undef Deja de estar definida una macro.
#if Compilación condicional si se cumple condición.
#ifdef Compilación condicional si la macro está definida.
#ifndef Compilación condicional si la macro no está definida.
#elif Compilación condicional si no se cumple condición anterior y sí la actual.
#else Compilación condicional si no se cumple condición.
#endif Fin de compilación condicional.
#line Establece valor de macros LINE y FILE .

Descargado por britney bonaldy (bricamacho92@gmail.com)

 #error Error con mensaje.
#pragma Establece opciones de compilación.
# Directiva nula, sin efecto.

COMPILACIÓN CONDICIONAL
Permite decidir si una parte del programa va a ser compilada o no, dependiendo de una
condición. En la compilación condicional se emplean diversas directivas, entre las que se pueden
destacar las siguientes:
#if Condición
La condición debe ser una expresión calculable en tiempo de compilación. Si la condición es
verdadera se incluirá en el código desde ese punto hasta encontrar un “else”, “elif” o “endif”. En
caso de que la condición sea falsa se procesaría el “else “o el “elif”.
#ifdef Macro
Funciona igual que el “if” pero la condición a cumplir es que una macro este definida o no.
#ifndef Macro
Funciona como “ifdef” pero al contrario, la condición se cumple si la macro no está definida.
#elif Condición
En caso de que se alcance esta directiva al no cumplirse la condición de un “if” o “ifdef”, se evalúa
la condición. Si la condición es verdadera se incluye hasta el siguiente “elif” o “endif”. En caso de
que la condición sea falsa se actúa igual que en un “if”.
#else
En caso de que no se cumpla las condiciones de un “if”, “ifdef” o “elif” y exista un “else” se
incluye el código desde el “else” hasta el siguiente “endif”.
#endif
Indica el final de una estructura “if” o “ifdef”.

EJERCICIOS
1. _Realizar un Programa en C con Macros que calcule el cubo de un numero
ingresado, sabiendo que CUBO=num*num*num

#include <stdio.h>
#include <stdlib.h>
#define CUBO num*num*num
int main()

Descargado por britney bonaldy (bricamacho92@gmail.com)

{
int x,num;
printf(“Ingrese el numero que desea sacarle el cubo\n\
n”); scanf(“%d”,&num);
x=CUBO;
printf(“El CUBO de %d es: %d\n\n\n”,num,x);
system(“PAUSE”);
return 0;
}

2. _Realizar un Programa en C con Macros donde P sea igual a printf, donde PI=3.1416 y
donde C sea igual a la velocidad de la luz (300000), mostrar estos datos en pantalla y luego
modificamos el valor de la velocidad luz multiplicándolo por PI / A y mostrarlo por
pantalla. NOTA: El usuario debe ingresar el valor de A.

#include <stdio.h>
#include <stdlib.h>
#define P printf
#define PI 3.1416
#define C 300000

int main()
{
float luz,a,x;
P(“Ingrese el valor de A\n\n”);
scanf(“%f”,&a);
x=C;
luz=x*PI/a;
P(“\nel valor de PI es: %f \n\n”,PI);
P(“el valor de la velocidad de la luz es: %f \n\n”,x);
P(“el valor de la velocidad de la luz modificado es: %f \n\n”,luz);

system(“PAUSE”);
return 0;
}

3. _Realizar un Programa en C con Macros donde se defina un valor cualquiera al cual se

le sacara el cubo y el cuadrado.

#include <stdio.h>
#include <stdlib.h>
#define NUM 4

int main()
{

Descargado por britney bonaldy (bricamacho92@gmail.com)

 int cubo,cuadrado;
cubo=NUM*NUM*NUM;
cuadrado=NUM*NUM;
printf(“El cubo del número 4 es: %d\n\n”,cubo);
printf(“El cuadrado del número 4 es:%d\n\n”,cuadrado);
system(“PAUSE”);
return 0;
}

4. _Realizar un Programa en C con Macros donde se defina A=800,B=700 y el valor de C

lo ingresara el usuario, mostrar los valores definidos en pantalla y luego de que el usuario
ingrese el valor de C mostrar los valores de A,B,C en forma DESCENDENTE Y
ASCENDENTE.

#include <stdio.h>
#include <stdlib.h>
#define A 800
#define B 700

int main()
{
int C;
printf(“El Valor de A es:%d\t\n”,A);
printf(“El Valor de B es:%d\t\n”,B);
printf(“Ingrese el Valor de C: “);
scanf(“%d”, &C);
printf(“\n”);
if(A>B &&
A>C)
{ if(B>
C)
{
printf(“Descendente: %d, %d, %d “,A,B,C); printf(“\
nAscendente: %d, %d, %d “,C,B,A);
}
else
{
printf(“Descendente: %d, %d, %d “,A,C,B); printf(“\
nAscendente: %d, %d, %d “,B,C,A);
}
}
else
if(B>C && B>A)
{ if(C>
A)
{
printf(“Descendente: %d, %d, %d “,B,C,A); printf(“\
nAscendente: %d, %d, %d “,A,C,B);

Descargado por britney bonaldy (bricamacho92@gmail.com)

}
else
{
printf(“Descendente: %d, %d, %d “,B,A,C); printf(“\
nAscendente: %d, %d, %d “,C,A,B);
}
}
else
if(C>A && C>B)
{ if(A>
B)
{
printf(“Descendente: %d, %d, %d “,C,A,B); printf(“\
nAscendente: %d, %d, %d “,B,A,C);
}
else
{
printf(“Descendente: %d, %d, %d “,C,B,A); printf(“\
nAscendente: %d, %d, %d “,A,B,C);
}
}

printf(“\n\n\n”);

system(“PAUSE”);
return 0;
}

ORDENAMIENTO Y BÚSQUEDA
QUÉ ES ORDENAMIENTO
Es la operación de arreglar los registros de una tabla en algún orden secuencial de acuerdo a
un criterio de ordenamiento. El ordenamiento se efectúa con base en el valor de algún
campo en un registro. El propósito principal de un ordenamiento es el de facilitar las
búsquedas de los miembros del conjunto ordenado.

BURBUJA
La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de
ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el
siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario
revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual
significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la
que suben por la lista los elementos durante los intercambios, como si fueran pequeñas
"burbujas". También es conocido como el método del intercambio directo. Dado que solo

Descargado por britney bonaldy (bricamacho92@gmail.com)

usa comparaciones para operar elementos, se lo considera un algoritmo de comparación,
siendo el más sencillo de implementar.
Este algoritmo es esencialmente un algoritmo de fuerza bruta lógica.

SELECCIÓN

El ordenamiento por selección (Selection Sort en inglés) es un algoritmo de

ordenamiento que requiere

O operaciones para ordenar una lista de n elementos.

INSERCIÓN

El ordenamiento por inserción (insertion sort en inglés) es una manera muy natural de
ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas
numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista
de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después,

cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se
compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un
elemento menor (todos los elementos mayores han sido desplazados una posición a la
10

Descargado por britney bonaldy (bricamacho92@gmail.com)

derecha) o cuando ya no se encuentran elementos (todos los elementos fueron desplazados
y este es el más pequeño). En este punto se inserta el elemento k+1 debiendo desplazarse
los demás elementos.

QUICK SORT
El ordenamiento rápido (quicksort en inglés) es un algoritmo creado por el científico
británico en computación C. A. R. Hoare basado en la técnica de divide y vencerás, que
permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.

MERGE SORT
El algoritmo de ordenamiento por mezcla (merge sort en inglés) es un algoritmo de
ordenamiento externo estable basado en la técnica divide y vencerás. Es de complejidad O
(nlog n).

HASHING
Hash: se refiere a una función o método para generar claves o llaves que representen de
manera casi unívoca a un documento, registro, archivo, etc., resumir o identificar un dato a
través de la probabilidad, utilizando una función hash o algoritmo hash. Un hash es el
resultado de dicha función o algoritmo.

Es un método de búsqueda que aumenta la velocidad de búsqueda, pero que no requiere que
los elementos estén ordenados. Consiste en asignar a cada elemento un índice mediante una
transformación del elemento. Esta correspondencia se realiza mediante una función de
conversión, llamada función hash. La correspondencia más sencilla es la identidad, esto es,
al número 0 se le asigna el índice 0, al elemento 1 el índice 1, y así sucesivamente. Pero si

11

Descargado por britney bonaldy (bricamacho92@gmail.com)

los números a almacenar son demasiado grandes esta función es inservible. Por ejemplo, se
quiere guardar en un array la información de los 1000 usuarios de una empresa, y se elige el
número de DNI como elemento identificativo. Es inviable hacer un array de 100.000.000
elementos, sobre todo porque se desaprovecha demasiado espacio. Por eso, se realiza una
transformación al número de DNI para que nos dé un número menor, por ejemplo coger las
3 últimas cifras para guardar a los empleados en un array de 1000 elementos. Para buscar a
uno de ellos, bastaría con realizarla transformación a su DNI y ver si está o no en el array.
EJERCICIOS
1. _Realizar un Programa en C donde el usuario ingrese valores y los muestre antes
de ordenar, y que luego los muestre en forma ascendente y en forma descendente
(BURBUJA)

#include <stdio.h>
#include <stdlib.h>

int main()
{
int num[100],n;
int i,j,k,temp;
printf("\nCuantos Valores desea Ingresar:\t\
t"); scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("\nIngrese un Numero:\t");
scanf("%d",&num[i]);
}
printf("\nNumeros antes de Ordenar\n\n\t");
for(j=0;j<n;j++)
{
printf("%d,",num[j]);
}
for(i=0;i<n;i++)
{
for(j=i;j<n;j++)
{
if(num[i]<num[j])
{
temp=num[i];
num[i]=num[j];
num[j]=temp;
}

12

Descargado por britney bonaldy (bricamacho92@gmail.com)

 }
}
printf("\n\nlos Numeros Ordenados Descendentemente son:\n\n\t"); for(k=0;k<n;k+
+)
{
printf("%d,",num[k]);
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(num[i]<num[j])
{
temp=num[i];
num[i]=num[j];
num[j]=temp;
}
}
}
printf("\n\nlos Numeros Ordenados Ascendentemente son:\n\n\t");
for(k=0;k<n;k++)
{
printf("%d,",num[k]);
}
printf("\n\n\n\n\n\n");

system("PAUSE");
return 0;
}

2. _Realizar un Programa en C donde el usuario ingrese valores y los muestre antes

de ordenar, y que luego los muestre en forma descendente (BURBUJA)

#include <stdio.h>
#include <stdlib.h>

int main()
{
int num[100],n;
int i,j,k,temp;
printf("ingrese cantidad de numeros\n");

13

Descargado por britney bonaldy (bricamacho92@gmail.com)

 scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("ingresar numeros\n");
scanf("%d",&num[i]);
}
printf("antes de ordenar\n");
for(j=0;j<n;j++)
{
printf("%d\n",num[j]);
}
for(i=0;i<n;i++)
{
for(j=i;j<n;j++)
{
if(num[i]<num[j])
{
temp=num[i];
num[i]=num[j];
num[j]=temp;
}
}
}
for(k=0;k<n;k++)
{
printf("los valores ordenados son: %d\n",num[k]);
}
system("PAUSE");
return 0;
}

3. _Realizar un Programa en C que muestre los valores dados(49,20,50,50,79,89)

en forma ascendente (BURBUJA)

#include <stdio.h>
#include <stdlib.h>

int main()
{
int tabla[6]={49,20,50,50,79,89};
int i,j,k,temp;

14

Descargado por britney bonaldy (bricamacho92@gmail.com)

 for (i=0;i<6;i++)
{
for(j=i;j<6;j++)
{
if(tabla[i]>tabla[j])
{
temp=tabla[i];
tabla[i]=tabla[j];
tabla[j]=temp;
}
}
}
for(k=0;k<6;k++)
{
printf("\t\n%d\n\n",tabla[k]);
}

system("PAUSE");
return 0;
}

UTILIZACION AVANZADA DE ARCHIVOS

Ficheros
El estándar de C contiene varias funciones para la edición de ficheros, estas están definidas
en la cabecera stdio.h y por lo general empiezan con la letra f, haciendo referencia a file.
Adicionalmente se agrega un tipo FILE, el cual se usará como apuntador a la información
del fichero. La secuencia que usaremos para realizar operaciones será la siguiente:
· Crear un apuntador del tipo FILE *
· Abrir el archivo utilizando la función fopen y asignándole el resultado de la llamada
a nuestro apuntador.
· Hacer las diversas operaciones (lectura, escritura, etc).
· Cerrar el archivo utilizando la función fclose.

Ü fopen
Esta función sirve para abrir y crear ficheros en disco.
El prototipo correspondiente de fopen es:

15

Descargado por britney bonaldy (bricamacho92@gmail.com)

 FILE * fopen (const char *filename, const char *opentype);
Los parámetros de entrada de fopen son:
Filename: una cadena que contiene un nombre de fichero válido.
opentype: especifica el tipo de fichero que se abrirá o se creará.

Una lista de parámetros opentype para la función fopen son:

"r" : abrir un archivo para lectura, el fichero debe existir.
"w" : abrir un archivo para escritura, se crea si no existe o se sobre escribe si existe.
"a" : abrir un archivo para escritura al final del contenido, si no existe se crea.
"rt" : abrir un archivo para lectura y escritura, el fichero debe existir.
"wt" : crear un archivo para lectura y escritura, se crea si no existe o se sobre escribe si
existe.
"r+b ó rb+" : Abre un archivo en modo binario para actualización (lectura y escritura).
"rb" : Abre un archivo en modo binario para lectura.

Adicionalmente hay tipos utilizando "b" (binary) los cuales no serán mostrados por ahora y
que solo se usan en los sistemas operativos que no pertenecen a la familia de unix.
Ü fclose
Esta función sirve para poder cerrar un fichero que se ha abierto.
El prototipo correspondiente de fclose es:
int fclose (FILE *stream);
Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha habido
algún error, el valor de retorno es la constante EOF.
Un ejemplo pequeño para abrir y cerrar el archivo llamado fichero.in en modo lectura:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
FILE *fp;
fp = fopen ( "fichero.in", "r" );

16

Descargado por britney bonaldy (bricamacho92@gmail.com)

 if (fp==NULL) {fputs ("File error”, stderr); exit (1);}
fclose ( fp );
return 0;
}
Como vemos, en el ejemplo se utilizó el opentype "r", que es para la lectura.
Otra cosa importante es que el lenguaje C no tiene dentro de sí una estructura para el
manejo de excepciones o de errores, por eso es necesario comprobar que el archivo fue
abierto con éxito "if (fp == NULL)". Si fopen pudo abrir el archivo con éxito devuelve la
referencia al archivo (FILE *), de lo contrario devuelve NULL y en este caso se deberá
revisar la dirección del archivo o los permisos del mismo. En estos ejemplos solo vamos a
dar una salida con un retorno de 1 que sirve para señalar que el programa termino por un
error.
ü feof
Esta función sirve para determinar si el cursor dentro del archivo encontró el
final (end of file). Existe otra forma de verificar el final del archivo que es comparar el
carácter que trae fgetc del archivo con el macro EOF declarado dentro de stdio.h, pero este
método no ofrece la misma seguridad (en especial al tratar con los archivos "binarios"). La
función feof siempre devolverá cero (Falso) si no es encontrado EOF en el archivo, de lo
contrario regresará un valor distinto de cero (Verdadero).
El prototipo correspondiente de feof es:
int feof(FILE *fichero);
ü rewind
Literalmente significa "rebobinar", sitúa el cursor de lectura/escritura al principio del
archivo.
El prototipo correspondiente de rewind es:
void rewind(FILE *fichero);
Lectura
Un archivo generalmente debe verse como un string (una cadena de caracteres) que está
guardado en el disco duro. Para trabajar con los archivos existen diferentes formas y
diferentes funciones. Las funciones que podríamos usar para leer un archivo son:
char fgetc(FILE *archivo)
char *fgets(char *buffer, int tamano, FILE *archivo)
size_t fread(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);

17

Descargado por britney bonaldy (bricamacho92@gmail.com)

int fscanf(FILE *fichero, const char *formato, argumento, ...);
Las primeras dos de estas funciones son muy parecidas entre sí. Pero la tercera, por el
número y el tipo de parámetros, nos podemos dar cuenta de que es muy diferente, por eso la
trataremos aparte junto al fwrite que es su contraparte para escritura.
ü fgetc
Esta función lee un carácter a la vez del archivo que está siendo señalado con el
puntero *archivo. En caso de que la lectura sea exitosa devuelve el carácter leído y en caso
de que no lo sea o de encontrar el final del archivo devuelve EOF.
El prototipo correspondiente de fgetc es:
char fgetc(FILE *archivo);
Esta función se usa generalmente para recorrer archivos de texto. A manera de ejemplo
vamos a suponer que tenemos un archivo de texto llamado "prueba.txt" en el mismo
directorio en que se encuentra el fuente de nuestro programa. Un pequeño programa que lea
ese archivo será:
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracter;
archivo = fopen("prueba.txt","r");
if (archivo == NULL){
printf("\nError de apertura del archivo. \n\n");
}else{
printf("\nEl contenido del archivo de prueba es \n\n");
while (feof(archivo) == 0)
{
caracter = fgetc(archivo);
printf("%c",caracter);
}
}

18

Descargado por britney bonaldy (bricamacho92@gmail.com)

 fclose(archivo);
return 0;
}
ü fgets
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o
hasta que lea un cambio de línea '\n' o un final de archivo EOF. En este último caso, el
carácter de cambio de línea '\n' también es leído.
El prototipo correspondiente de fgets es:
char *fgets(char *buffer, int tamaño, FILE *archivo);
El primer parámetro buffer lo hemos llamado así porque es un puntero a un espacio de
memoria del tipo char (podríamos usar un arreglo de char). El segundo parámetro es
tamaño que es el límite en cantidad de caracteres a leer para la función fgets. Y por último
el puntero del archivo por supuesto que es la forma en que fgets sabrá a que archivo debe
leer.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracteres[100];
archivo = fopen("prueba.txt","r");
if (archivo == NULL)
exit(1);
printf("\nEl contenido del archivo de prueba es \n\n");
while (feof(archivo) == 0)
{
fgets(caracteres,100,archivo);
printf("%s",caracteres);
}
system("PAUSE");

19

Descargado por britney bonaldy (bricamacho92@gmail.com)

fclose(archivo);
return 0;
}
Este es el mismo ejemplo de antes con la diferencia de que este hace uso de fgets en lugar
de fgetc. La función fgets se comporta de la siguiente manera, leerá del archivo apuntado
por archivo los caracteres que encuentre y a ponerlos en buffer hasta que lea un carácter
menos que la cantidad de caracteres especificada en tamaño o hasta que encuentre el final
de una línea (\n) o hasta que encuentre el final del archivo (EOF). En este ejemplo no
vamos a profundizar más que para decir que caracteres es un buffer, los pormenores serán
explicados en la sección de manejo dinámico de memoria.
El beneficio de esta función es que se puede obtener una línea completa a la vez. Y
resulta muy útil para algunos fines como la construcción de un parser de algún tipo de
archivo de texto.
ü fread
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de un arreglo de
elementos "count", cada uno de los cuales tiene un tamaño definido por "size". Luego los
guarda en el bloque de memoria especificado por "ptr". El indicador de posición de la
cadena de caracteres avanza hasta leer la totalidad de bytes. Si esto es exitoso la cantidad de
bytes leídos es (size*count).
DESCRIPTORES DE ARCHIVOS
PARAMETROS:
ptr : Puntero a un bloque de memoria con un tamaño mínimo de (size*count) bytes.
size : Tamaño en bytes de cada elemento (de los que voy a leer).
count : Número de elementos, los cuales tienen un tamaño "size".
stream: Puntero a objetos FILE, que especifica la cadena de entrada.
fscanf
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la entrada se toma
de un fichero en lugar del teclado.
El prototipo correspondiente de fscanf es:
int fscanf(FILE *fichero, const char *formato, argumento, ...);
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en modo lectura y
leyendo dentro de él.

20

Descargado por britney bonaldy (bricamacho92@gmail.com)

#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100];
fp = fopen ( "fichero.txt", "r" );
fscanf(fp, "%s" ,buffer);
printf("%s",buffer);
fclose ( fp );
return 0;
}
Escritura
Así como podemos leer datos desde un fichero, también se pueden crear y escribir ficheros
con la información que deseamos almacenar, Para trabajar con los archivos existen
diferentes formas y diferentes funciones. Las funciones que podríamos usar para escribir
dentro de un archivo son:
• int fputc(int caracter, FILE *archivo)
• int fputs(const char *buffer, FILE *archivo)
• size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
• int fprintf(FILE *archivo, const char *formato, argumento, ...);
ü fputc
Esta función escribe un carácter a la vez del archivo que está siendo señalado con el
puntero *archivo. El valor de retorno es el carácter escrito, si la operación fue completada
con éxito, en caso contrario será EOF.
El prototipo correspondiente de fputc es:
int fputc(int carácter, FILE *archivo);
Mostramos un ejemplo del uso de fputc en un "fichero.txt", se escribirá dentro del fichero
hasta que presionemos la tecla enter.
#include <stdio.h>
int main ( int argc, char **argv )

21

Descargado por britney bonaldy (bricamacho92@gmail.com)

{
FILE *fp;
char caracter;
fp = fopen ( "fichero.txt", "r+" ); printf("\
nIntrouce un texto al fichero: ");
while((caracter = getchar()) != '\n')
{
printf("%c", fputc(caracter, fp));
}
fclose ( fp );
return 0;
}
ü fputs
La función fputs escribe una cadena en un fichero. No se añade el carácter de retorno de
línea ni el carácter nulo final. El valor de retorno es un número no negativo o EOF en caso
de error. Los parámetros de entrada son la cadena a escribir y un puntero a la estructura
FILE del fichero donde se realizará la escritura.
El prototipo correspondiente de fputs es:
int fputs(const char *buffer, FILE *archivo)
Para ver su funcionamiento mostramos el siguiente ejemplo:
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char cadena[] = "Mostrando el uso de fputs en un fichero.\n";
fp = fopen ( "fichero.txt", "r+" );
fputs( cadena, fp );
fclose ( fp );
return 0;

22

Descargado por britney bonaldy (bricamacho92@gmail.com)

}
ü fwrite
Esta función está pensada para trabajar con registros de longitud constante y forma pareja
con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma longitud
almacenados a partir de una dirección de memoria determinada. El valor de retorno es el
número de registros escritos, no el número de bytes. Los parámetros son: un puntero a la
zona de memoria de donde se obtendrán los datos a escribir, el tamaño de cada registro, el
número de registros a escribir y un puntero a la estructura FILE del fichero al que se hará la
escritura.
El prototipo correspondiente de fwrite es:
size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
ü fprintf
La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida se
dirige a un archivo en lugar de a la pantalla.
El prototipo correspondiente de fprintf es:
int fprintf(FILE *archivo, const char *formato, argumento, ...);
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en modo
lectura/escritura y escribimos dentro de él.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100] = "Esto es un texto dentro del fichero.";
fp = fopen ( "fichero.txt", "r+" );
fprintf(fp, buffer);
fprintf(fp, "%s", "\nEsto es otro texto dentro del fichero.");
fclose ( fp );
return 0;
}
EJERCICIOS

23

Descargado por britney bonaldy (bricamacho92@gmail.com)

1. _Realizar un Programa en C que permita abrir y escribir en un archivo ya existente.

#include <stdio.h>
#include <stdlib.h>

int main()
{
FILE*fp;
char caracter;
fp=fopen("prueba2.txt","r+");
printf("introduce el texto");
while((caracter=getchar())!='\n')
{
printf("%c",fputc(caracter,fp));
}
fclose(fp);

system("PAUSE");
return 0;
}
2. _Realizar un Programa en C que permita crear un archivo para escritura y lectura.

#include <stdio.h>
#include <stdlib.h>

int main()
{
FILE*fp;
char caracter;
fp=fopen("prueba2.txt","w");
printf("introduce el texto");
while((caracter=getchar())!='\n')
{
printf("%c",fputc(caracter,fp));
}
fclose(fp);

system("PAUSE");
return 0;
}
3. _Realizar un Programa en C que permita abrir un archivo para lectura.
#include <stdio.h>

24

Descargado por britney bonaldy (bricamacho92@gmail.com)

int main()
{
FILE*archivo;
char buffer[100];
archivo=fopen("prueba.txt","r");
fscanf(archivo,"%s",buffer);
printf("%s",buffer);
fclose(archivo);

system("PAUSE");

return 0;
}
4. _Realizar un Programa en C que muestre el uso de fputs en un fichero.
#include <stdio.h>

int main()
{
FILE*fp;

char cadena[] ="Mostrando el uso de fputs en un fichero.\n";

fp=fopen("prueba.txt","a+");

fputs(cadena,fp);

fclose(fp);

return 0;

}
5. _Realizar un Programa en C que muestre el uso de fprintf en un fichero.

#include <stdio.h>
int main ()
{
FILE *fp;

char buffer[100] = "Esto es un texto dentro del fichero.";

fp = fopen ( "prueba.txt", "a+" );

fprintf(fp, buffer);

25

Descargado por britney bonaldy (bricamacho92@gmail.com)

 fprintf(fp, "%s", "\nEsto es otro texto dentro del fichero.");

fclose ( fp );

return 0;
}

CONCLUSIÓN

Los lenguajes de alto nivel se desarrollaron con el objetivo de ser más accesibles y
entendibles por la mayoría de programadores, de manera que los programadores pudieran
concentrarse más en resolver la tarea o los problemas y no en el lenguaje que la maquina
tenía que entender.
C++ surge de fusionar dos ideas: la eficiencia del lenguaje C para poder acceder al
hardware al ejecutar tareas que realmente demandaban recursos de memoria; y las ideas de
abstracción que representan las el nuevo conceptos de clases y objetos.
El lenguaje C++ presenta grandes herramientas de desarrollo para los programadores
como las De funciones, bibliotecas, clases y los objetos. Manera que el programador se
ocupa de utilizar dichas herramientas para resolver un problema específico.
El lenguaje C++ posee una serie de características que lo hacen distinto del lenguaje C.
Aunque es posible verlo como una simple extensión del lenguaje C, en realidad implica un
cambio en la forma de pensar por parte del programador.

26

Descargado por britney bonaldy (bricamacho92@gmail.com)