Este documento proporciona una introducción al lenguaje de programación C/C++. Explica que C es un lenguaje de programación estructurado desarrollado originalmente en 1972 y que es ampliamente utilizado para desarrollar sistemas operativos y aplicaciones. Define conceptos clave como identificadores, variables, tipos de datos, estructuras de control, funciones y entrada/salida. Además, presenta una guía de referencia sobre las características y funcionalidades principales del lenguaje C/C++.

1. UNIVERSIDAD CENTROAMERICANA
Facultad de Ciencia, Tecnología y Ambiente
Ingeniería en sistemas de la información
Manual
de
Lenguaje
C/C++
Elaborado por: RALPH ALEJANDRO CASTELLÓN LAGUNA
Docente: ELSNER BOANERGE GONZÁLEZ ORTEGA

2. Tabla de contenido
¿Qué es el lenguaje C?..........................................................................................................4
Identificadores.....................................................................................................................4
Variables:.............................................................................................................................5
Definición de variable .......................................................................................................5
Uso de variables globales y locales.....................................................................................5
Variable local....................................................................................................................5
Variable Global.................................................................................................................6
Declaración de variables:......................................................................................................6
OPERADORES DE C / C++.......................................................................................................7
Constantes...........................................................................................................................8
casting.................................................................................................................................8
Arreglos...............................................................................................................................8
Concepto.........................................................................................................................8
Estructuras de datos.............................................................................................................9
Palabras reservadas:...........................................................................................................10
ENTRADA SALIDA ...............................................................................................................10
Printf y scanf..................................................................................................................10
Entrada de datos: función scanf() ....................................................................................10
Salida de datos: función scanf().......................................................................................11
Entrada y salida sin formato................................................................................................12
archivo de acceso aleatorio.................................................................................................12
Programación estructurada:................................................................................................13
SENTENCIAS DE CONTROL...................................................................................................14
Estructura de Selección if… else.......................................................................................14
Sentencia Switch ............................................................................................................14
FOR................................................................................................................................14
Do - While......................................................................................................................14
Funciones ..........................................................................................................................15
Ficheros:............................................................................................................................15
Función fclose:...............................................................................................................16
Función fgetc:.................................................................................................................16
Función fputc:................................................................................................................16
Función feof:..................................................................................................................17

3. Función rewind:..............................................................................................................17
Función fgets:.................................................................................................................17
Función fputs:................................................................................................................18
Función fread:................................................................................................................18
Función fwrite:...............................................................................................................18
Función fprintf:...............................................................................................................19
Función fscanf:...............................................................................................................20
Función fflush:................................................................................................................20
Función fseek:................................................................................................................20
Función ftell:..................................................................................................................21
LIBRERÍA STRING:...............................................................................................................21
ANEXOS.............................................................................................................................23
Ejercicios:.......................................................................................................................23
ATM:..........................................................................................................................23
IR...............................................................................................................................25
Empleado...................................................................................................................26
Tarea.................................................................................................................................31

4. ¿Qué es el lenguaje C?
Lenguaje de programación C. También conocido como “Lenguaje de programación de
sistemas” desarrollado en el año 1972 por Dennis Ritchie para UNIX un sistema
operativo multiplataforma. El lenguaje C es del tipo lenguaje estructurado como
son Pascal, Fortran, Basic. Sus instrucciones son muy parecidas a otros lenguajes
incluyendo sentencias como if, else, for, do y while... . Aunque C es un lenguaje de
alto nivel (puesto que es estructurado y posee sentencias y funciones que
simplifican su funcionamiento) tenemos la posibilidad de programar a bajo nivel
(como en el Assembler tocando los registros, memoria etc. ). Para simplificar el
funcionamiento del lenguaje C tiene incluidas librerías de funciones que pueden ser
incluidas haciendo referencia la librería que las incluye, es decir que si queremos
usar una función para borrar la pantalla tendremos que incluir en nuestro programa
la librería que tiene la función para borrar la pantalla.
Identificadores
Un identificador es una 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ándar de lenguaje C no especifica 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 programador tiene libertad para darle
cualquier nombre a un identificador, siguiendo estas reglas:
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 pueden existir dos identificadores iguales, es decir, dos elementos de un
programa no pueden nombrarse de la misma forma. Sin embargo, un
identificador puede 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 C existen identificadores que podrían tener uno o varios puntos,
tales como: datos.nombrePersonal

5. Algunos identificadores que es preferible no utilizar:
A9, 1, Z, primer-nombre, esto porque el identificador debe representar claramente
el dato que se almacena en la variable, además el ultimo identificador no es válido
porque 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.
Variables:
Definición de variable
Una variable es un objeto del lenguaje cuyo valor se puede cambiar. Antes de
utilizar una variable ésta debe de ser declarada. Al declarar una variable, se le
asocia un identificador, es decir, un nombre, con un tipo de almacenamiento cuya
forma determina la visibilidad y existencia de la variable.
TIPO DE DATOS
SE
ESCRIBE
MEMORIA
REQUERIDA*
RANGO
ORIENTATIVO*
EQUIVALENCIA
EN
PSEUDOCÓDIGO
OBSERVACIONES
Entero int 2 bytes - 32768 a 32767 Entero
Uso en contadores, control de
bucles etc.
Entero largo long 4 bytes
- 2147483648 a
2147483647
Entero
Igual que int pero admite un
rango más amplio
Decimal simple float 4 bytes
- 3,4·1038 a
3,4·1038
Real
Hasta 6 decimales. También
admite enteros
Decimal doble double 8 bytes
- 1,79·10308
a
1,79·10308
Real
Hasta 14 decimales. También
admite enteros
Carácter char 1 bytes 0 a 255 Alfanumérica
Carácter, independiente o parte
de una cadena
Uso de variables globales y locales
Variable local
Una variablelocales aquella cuyoámbito se restringe a la funciónquela 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

6. 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 es aquella que se define fuera del cuerpo de cualquier función,
normalmente al principio del programa, después de la definición de los archivos de
biblioteca (#include), de la definición de constantes simbólicas y antes de cualquier
funció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.
Declaración de variables:
La declaración de variables en C debe hacerse al principio del programa claro eta
que será después de la línea int main(), que constituye el inicio del código ejecutivo
de nuestro programa y La sintaxis que usaremos será:
int [Nombre de variable];
En C podemos declarar variables en múltiples líneas una por línea pero también
varias variables en una línea. Existen distintas formas para realizar
declaraciones. Como por ejemplo:
Expresión abreviada Equivalente
a) int i, j, k;
a´) int i;
int j;
int k;
b) int i, j, k; b´) int i; int j; int k;
c) int i=0, j=4, k=76;
c´) int i=0;
int j=4;
int k=76;
d) int i=0, j=4, k=76; d´) int i=0; int j=4; int k=76;
Ejemplos de asignación de contenidos son estos:
Declaración Ejemplo asignación contenidos

7. int A; A = 123;
float A; A = - 3323.57;
char A; A = 'p';
char A; A = '1';
int salario; salario = 30500;
float salario; salario = 30500;
int A, B, suma;
A = 5 + 2;
B = 32;
suma = A + B; [suma valdrá 39]
int A, B, C, D, E;
A = 5;
B = 32;
C = A * B; [C toma el valor 160]
D = A + C; [D toma el valor 165]
E = D; [E toma el valor 165]
int agotamiento; agotamiento = 0; [Usamos un entero para simular un booleano]
OPERADORES DE C / C++
Son los operadores que permiten realizar las Operaciones Aritméticas en C / C++
(Son esenciales en los lenguajes de programación).

8. 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 los lenguajes de programación permiten
el manejo de diferentes tipos de constantes; éstas pueden ser enteras, reales,
caracteres y cadenas.
casting
consiste en almacenar un dato de una variable en otra diferente, aunque para esto
se debe tomar en cuenta que esto no se puede hacer con todos los tipos 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.
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 alta al último. Por sí mismo, el nombre del
arreglo apunta a la dirección del primer elemento del arreglo.
Para acceder a un elemento almacenado en un arreglo se especifica el identificador
de la variable mas el índice entre corchete: indent [índice].
Arreglo[5]: 0 1 2 3 4

9. Un arreglo se caracteriza por:
1. Ser una lista de un número finito de n elementos del mismo tipo.
2. Almacenar los elementos del arreglo en memoria contigua.
Cuando decimos memoria contigua nos referimos a que el espacio de memoria que
se reserva es uno tras otro es decir seguido
3. Tener un único nombre de variable que representa a todos los elementos y éstos
se diferencian por un índice o subíndice.
Los arreglos se clasifican en:
Unidimensionales (vectores o listas)
Bidimensionales (tablas o matrices)
Multidimensionales (más de dos dimensiones)
Los más utilizados son los unidimensionales y los bidimensionales
Estructuras de datos
Una estructura define una plantilla con la que posteriormente se puede declarar
una variable. Una de las características de las estructuras es que hay que
definirlas antes de usarlas en la declaración de variables. En la definición no 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 estructura se empieza por definir su tipo para ello realizamos una
acción similar a la de definición de una variable, para esto 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.
Observemos la forma más común de declarar una estructura:
struct empleado
{
char nombre[35];
int edad;
char sexo;
double sal;

10. };
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 datos;
Palabras reservadas:
Palabra reservada utilidad
abs() Calcula el valor absoluto
char Tipo de dato carácter
Case Si se cumple un caso
Default Ninguna opción de la selectiva múltiple
Typedef Crea un nuevo nombre de tipo para un tipo de dato
ya definido
For Estructura repetitiva (o de ciclo)
int Tipo de dato entero
{ Inicio del programa o de un bloque
} Fin del programa o de un bloque
Do Estructura repetitiva
Printf Imprime en pantalla
Puts Imprime una cadena
scanf Lee una variable
Main Programa principal
struct Registro o estructura
return Regresa valor a otra función
ENTRADA SALIDA
Printf y scanf
El lenguaje C no tiene palabras reservadas para la e/s estándar del sistema
(teclado y pantalla). Estas operaciones se realizan mediante funciones de
biblioteca que encontramos en el archivo de cabecera stdio.h (standard input-
output header). La e/s con formato se realiza por medio de las funciones scanf() y
printf. Las f de scanf() y de printf() significan “con formato”.
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 cadena de control tiene uno o varios especificadores o códigos de formato que
harán referencia al tipo de dato de los argumentos y, si se desea, su anchura. Los

11. códigos estará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 computadora en que se encuentra la variable para poder almacenar la
información obtenida, para ello utilizaremos el símbolo ampersand (&), que
colocaremos antes del nombre de cada variable. Por lo tanto, 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];
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.
Salida de datos: función scanf()
printf (cadena de control de formato, otros argumentos);
la cadena de control de formato describe el formato de salida y, otros argumentos
(los cuales son opcionales) corresponden a cada especificación de conversión de la
cadena de control de formato. Cada especificación de conversión comienza con un
signo de porcentaje que termina con un especificador de conversión. Puede haber
muchas especificaciones de conversión en una cadena de control de formato.
Algunas cosas que debemos tomar en cuenta es no olvidar cerrar los paréntesis,
por presentación debemos editar claras las salidas de un programa, para que sean
más legibles y poder disminuir los 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).

12. 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; por ejemplo, en el
formato %s la letra ese (s) es el carácter de conversión para imprimir cadenas.
Debe haber el mismo número de códigos de formato que de argumentos y cada uno
de éstos debe tener un orden. En caso contrario el resultado no será correcto.
Entrada y salida sin formato
Las funcionesprincipalesque realizanlaentradaysalidasinformatoson:
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.
justificando a la derecha. El relleno es blanco.
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, hacia un
área en memoria que comienza con la dirección especificada. Ahora, cuando se
escribe un entero, en lugar de utilizar
fprintf( ptrF, “%d”, numero );
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 numero hacia el archivo representado por ptrF (más adelante
explicaremos el argumento 1). Posteriormente, fread puede utilizarse para leer 4
de estos bytes dentro de la variable entera numero. Aunque fread y fwrite leen y
escriben datos, tales como enteros, de tamaño fijo en lugar de formatos de tamaño
variable, los datos que manipulan se procesan en el formato fuente la computadora

13. (es decir, bytes o datos), en lugar del formato de printf y scanf legible para el
humano.
Programación estructurada:
La programación estructurada es un paradigma o forma de programar. Es un
conjunto de técnicas que nos permiten desarrollar programas fáciles de escribir,
verificar, leer y mantener e incluyen:
1. Diseño descendente (top-down).
2. Estructuras de datos.
3. Estructuras de control.
4. Programación modular.
Nosotros solo hemos estado usando el diseño descendente y con el cual hemos
trabajado en code:::blok.
En este caso usaremos la palabra reservada struct que sirve para abrir un módulo.
Struct nos sirve para crear un módulo o módulos y así crear un diseño descendente
o top-down y así crear programas más fáciles de encontrar errores, leer y por
supuesto comprender en programa creado.
Un ejemplo de esto podría ser:
#include <iostream>
using namespace std;
int main()
{
struct
{
string nombre;
char inicial;
int edad;
float nota;
} persona;
persona.nombre = "Juan";

14. persona.inicial = 'J';
persona.edad = 20;
persona.nota = 7.5;
cout << "La edad es " << persona.edad;
return 0;
}
SENTENCIAS DE CONTROL
Estructura de Selección if… else
Las sentencias de decisión o también llamadas de CONTROL DE FLUJO son
estructuras de control que realizan una pregunta la cual retorna verdadero o falso
(evalúa una condición) y selecciona la siguiente instrucción a ejecutar dependiendo
la respuesta o resultado.
Sentencia Switch
Permite seleccionar entre múltiples alternativas posibles. La expresión del switch
es una variable int o char, que puede tomar los valores, entre otros, dados por
"opción 1", "opcion 2", etc. Es una función por excelencia para Menús.
FOR
Es una estructura de control en programación en la que se puede indicar de
antemano el número mínimo de iteraciones que la instrucción realizará
While
Tiene cierta semejanza con el bucle for, así es en el uso de una inicialización, una
condición y un incremento. Otra de sus similitudes es el momento en el que analizan
la condición que en ambos es antes de ejecutar el bucle.
Do - While
Los ciclos do-while son una estructura de control cíclica, los cuales nos permiten
ejecutar una o varias líneas de código de forma repetitiva sin necesidad de tener
un valor inicial e incluso a veces sin siquiera conocer cuándo se va a dar el valor
final, hasta aquí son similares a los ciclos while, sin embargo el ciclo do-while nos
permite añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de
ejecutar primero el bloque de instrucciones antes de evaluar la condición
necesaria, de este modo los ciclos do-while, son más efectivos para algunas
situaciones específicas. En resumen, un ciclo do-while, es una estructura de control

15. cíclica que permite ejecutar de manera repetitiva un bloque de instrucciones sin
evaluar de forma inmediata una condición específica, sino evaluándola justo
después de ejecutar por primera vez el bloque de instrucciones.
Funciones
Las funciones permiten a los usuarios dividir un programa en módulos. Aplicando el
termino muy famoso en programación divide y vencerás es decir es más fácil dividir
el problema en problemas pequeños y así poder solucionarlos de manera
independiente con el objetivo sé que estas acciones aporten a un problema macro
esto también esto esta denominado en la programación descendente. Todas las
variables que se definen en una 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. Los parámetros proporcionan los medios para transferir
información entre funciones. Los parámetros de una función también son variables
locales de dicha función.
Ficheros:
C define la estructura de datos FILE en el fichero de cabecera stdio.h para el
manejo de ficheros. Nosotros siempre usaremos punteros a estas estructuras.
La definición de ésta estructura depende del compilador, pero en general
mantienen un campo con la posición actual de lectura/escritura, un buffer para
mejorar las prestaciones de acceso al fichero y algunos campos para uso interno.
Sintaxis:
FILE *fopen(char *nombre, char *modo);
Esta función sirve para abrir y crear ficheros en disco. El valor de retorno es un
puntero a una estructura FILE. Los parámetros de entrada son:
nombre: una cadena que contiene un nombre de fichero válido, esto depende del
sistema operativo que estemos usando. El nombre puede incluir el camino completo.
modo: especifica en tipo de fichero que se abrirá o se creará y el tipo de datos que
puede contener, de texto o binarios:
r: sólo lectura. El fichero debe existir.
w: se abre para escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
a: añadir, se abre para escritura, el cursor se situa al final del fichero. Si el
fichero no existe, se crea.

16. r+: lectura y escritura. El fichero debe existir.
w+: lectura y escritura, se crea un fichero nuevo o se sobreescribe si ya existe.
a+: añadir, lectura y escritura, el cursor se situa al final del fichero. Si el fichero
no existe, se crea.
t: tipo texto, si no se especifica "t" ni "b", se asume por defecto que es "t"
b: tipo binario.
Función fclose:
Sintaxis:
int fclose(FILE *fichero);
Es importante cerrar los ficheros abiertos antes de abandonar la aplicación. Esta
función sirve para eso. Cerrar un fichero almacena los datos que aún están en el
buffer de memoria, y actualiza algunos datos de la cabecera del fichero que
mantiene el sistema operativo. Además permite que otros programas puedan abrir
el fichero para su uso. Muy a menudo, los ficheros no pueden ser compartidos por
varios programas.
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. El parámetro es un
puntero a la estructura FILE del fichero que queremos cerrar.
Función fgetc:
Sintaxis:
int fgetc(FILE *fichero);
Esta función lee un carácter desde un fichero.
El valor de retorno es el carácter leído como un unsigned char convertido a int. Si
no hay ningún carácter disponible, el valor de retorno es EOF. El parámetro es un
puntero a una estructura FILE del fichero del que se hará la lectura.
Función fputc:
Sintaxis:
int fputc(int caracter, FILE *fichero);
Esta función escribe un carácter a un fichero.
El valor de retorno es el carácter escrito, si la operación fue completada con éxito,
en caso contrario será EOF. Los parámetros de entrada son el carácter a escribir,
convertido a int y un puntero a una estructura FILE del fichero en el que se hará la
escritura.

17. Función feof:
Sintaxis:
int feof(FILE *fichero);
Esta función sirve para comprobar si se ha alcanzado el final del fichero. Muy
frecuentemente deberemos trabajar con todos los valores almacenados en un
archivo de forma secuencial, la forma que suelen tener los bucles para leer todos
los datos de un archivo es permanecer leyendo mientras no se detecte el fin de
fichero. Esta función suele usarse como prueba para verificar si se ha alcanzado o
no ese punto.
El valor de retorno es distinto de cero sólo si no se ha alcanzado el fin de fichero.
El parámetro es un puntero a la estructura FILE del fichero que queremos
verificar.
Función rewind:
Sintaxis:
void rewind(FILE *fichero)
Es una funciónheredadade lostiemposde lascintasmagnéticas.Literalmentesignifica
"rebobinar",yhace referenciaaque para volveral principiode unarchivoalmacenadoen
cinta,había que rebobinarla.Esoesloque hace éstafunción,sitúael cursorde
lectura/escrituraal principiodel archivo.
El parámetroesun punteroa la estructura FILE del ficheroque queremosrebobinar.
Ejemplos:
// ejemplo1.c: Muestra un fichero dos veces.
#include <stdio.h>
int main()
{
FILE *fichero;
fichero = fopen("ejemplo1.c", "r");
while(!feof(fichero)) fputc(fgetc(fichero), stdout);
rewind(fichero);
while(!feof(fichero)) fputc(fgetc(fichero), stdout);
fclose(fichero);
getchar();
return 0;
}
Función fgets:
Sintaxis:
char *fgets(char *cadena, int n, FILE *fichero);

18. Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1
caracteres o hasta que lea un retorno de línea. En este último caso, el carácter de
retorno de línea también es leído.
El parámetro n nos permite limitar la lectura para evitar derbordar el espacio
disponible en la cadena.
El valor de retorno es un puntero a la cadena leída, si se leyó con éxito, y
es NULL si se detecta el final del fichero o si hay un error. Los parámetros son: la
cadena a leer, el número de caracteres máximo a leer y un puntero a una
estructura FILE del fichero del que se leerá.
Función fputs:
Sintaxis:
int fputs(const char *cadena, FILE *stream);
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.
Función fread:
Sintaxis:
size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE
*fichero);
Esta función está pensada para trabajar con registros de longitud constante. Es
capaz de leer desde un fichero uno o varios registros de la misma longitud y a
partir de una dirección de memoria determinada. El usuario es responsable de
asegurarse de que hay espacio suficiente para contener la información leída.
El valor de retorno es el número de registros leídos, no el número de bytes. Los
parámetros son: un puntero a la zona de memoria donde se almacenarán los datos
leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la
estructura FILE del fichero del que se hará la lectura.
Función fwrite:
Sintaxis:
size_t fwrite(void *puntero, size_t tamaño, size_t nregistros, FILE
*fichero);
Esta función también está pensada para trabajar con registros de longitud
constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o

19. 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 donde se almacenarán los datos
leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la
estructura FILE del fichero del que se hará la lectura.
Ejemplo:
// copia.c: Copia de ficheros
// Uso: copia <fichero_origen> <fichero_destino>
#include <stdio.h>
int main(int argc, char **argv) {
FILE *fe, *fs;
unsigned char buffer[2048]; // Buffer de 2 Kbytes
int bytesLeidos;
if(argc != 3) {
printf("Usar: copia <fichero_origen> <fichero_destino>n");
return 1;
}
// Abrir el fichero de entrada en lectura y binario
fe = fopen(argv[1], "rb");
if(!fe) {
printf("El fichero %s no existe o no puede ser abierto.n",
argv[1]);
return 1;
}
// Crear o sobreescribir el fichero de salida en binario
fs = fopen(argv[2], "wb");
if(!fs) {
printf("El fichero %s no puede ser creado.n", argv[2]);
fclose(fe);
return 1;
}
// Bucle de copia:
while((bytesLeidos = fread(buffer, 1, 2048, fe)))
fwrite(buffer, 1, bytesLeidos, fs);
// Cerrar ficheros:
fclose(fe);
fclose(fs);
return 0;
}
Función fprintf:
Sintaxis:
int fprintf(FILE *fichero, const char *formato, ...);

20. La función fprintf funciona igual que printf en cuanto a parámetros, pero la salida
se dirige a un fichero en lugar de a la pantalla.
Función fscanf:
Sintaxis:
int fscanf(FILE *fichero, const char *formato, ...);
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.
Función fflush:
Sintaxis:
int fflush(FILE *fichero);
Esta función fuerza la salida de los datos acumulados en el buffer de salida
del fichero. Para mejorar las prestaciones del manejo de ficheros se utilizan
buffers, almacenes temporales de datos en memoria, las operaciones de salida se
hacen a través del buffer, y sólo cuando el buffer se llena se realiza la escritura
en el disco y se vacía el buffer. En ocasiones nos hace falta vaciar ese buffer de
un modo manual, para eso sirve ésta función.
El valor de retorno es cero si la función se ejecutó con éxito, y EOF si hubo algún
error. El parámetro de entrada es un puntero a la estructura FILE del fichero del
que se quiere vaciar el buffer. Si es NULL se hará el vaciado de todos los ficheros
abiertos.
Funciones C específicas para ficheros de acceso aleatorio
Función fseek:
Sintaxis:
int fseek(FILE *fichero, long int desplazamiento, int origen);
Esta función sirve para situar el cursor del fichero para leer o escribir en el lugar
deseado.
El valor de retorno es cero si la función tuvo éxito, y un valor distinto de cero si
hubo algún error.
Los parámetros de entrada son: un puntero a una estructura FILE del fichero en el
que queremos cambiar el cursor de lectura/escritura, el valor del desplazamiento y
el punto de origen desde el que se calculará el desplazamiento.
El parámetro origen puede tener tres posibles valores:

21. SEEK_SET el desplazamiento se cuenta desde el principio del fichero. El primer
byte del fichero tiene un desplazamiento cero.
SEEK_CUR el desplazamiento se cuenta desde la posición actual del cursor.
SEEK_END el desplazamiento se cuenta desde el final del fichero.
Función ftell:
Sintaxis:
long int ftell(FILE *fichero);
La función ftell sirve para averiguar la posición actual del cursor de
lectura/excritura de un fichero.
El valor de retorno será esa posición, o -1 si hay algún error.
El parámetro de entrada es un puntero a una estructura FILE del fichero del que
queremos leer la posición del cursor de lectura/escritura.
LIBRERÍA STRING:
Strings (Cadena de caracteres) En C no existe un tipo de dato y operadores para
el tratamiento de cadenas de caracteres de manera “atómica” Un string es una
cadena de cero o más caracteres finalizados en cero '0', NUL o carácter '0' para
detectar el final del string Declaración de na string char saludo[5]; Asignación -
en la declaración: char saludo[5] = “hola”; // termina en NUL
char saludo[5] = {'h','o','l','a','0'}; - en otro tipo de sentencias usando funciones
de librería (string.h) Error: saludo = “chau”;
Strings – Visualización Mediante printf de stdio.h
int printf(const char *format, ...); empleando el modificado de formato %s
char cadena[9]=”sin tres”; . . . printf(“No hay dos %s“, cadena); El formato %20s:
texto a la derecha, campo de 20 caracteres %-15s: texto a la izquierda, campo de
15 caracteres.
Strings – Funciones de string.h Establecer contenido al string
char *strcpy (char *destino, char const *origen); Concatenar
char *strcat (char *destino, char const *origen); Es responsabilidad del
programador asegurar que - la región de memoria destino debe ser
suficientemente grande - las regiones de memoria destino y origen no deben
superponerse.
Strings – Funciones de string.h Obtener longitud size_t strlen (const char *s); //
no considera el '0' Comparar cadenas
int strcmp (const char *s1, const char *s2); (retorna >0 si s1>s2, ==0 si s1==s2.

22. Strings – Funciones de string.h Búsqueda de caracteres y patrones
char *strchr (const char *s, int c) Retorna un puntero a la primer ocurrencia del
caracter c char *strrchr (const char *s, int c) Retorna un puntero a la última
ocurrencia del caracter c char *strstr(const char *string, const char *substring)
Busca la primer ocurrencia de substring en string
char *strcasestr(const char *string, const char *substring) Igual que strstr pero
ignora mayúsculas y minúsculas.
Strings – Funciones de string.h Memory Functions A diferencia de las funciones
str__ no finalizan al detectar NUL
void *memcpy (void *dest, const void *ori, size_t cant) Copia cant bytes de un área
de memoria a otra (no deben superponerse) Retorna un puntero a dest
void *memcmp (const void *a, const void *b, size_t cant) Comportamiento similar a
strcmop void *memmove (void *dest, const void *ori, size_t cant) Copia cant bytes
desde ori a dest. Las direcciones de memoria pueden superponerse. Retorna un
puntero a dest.

23. ANEXOS
Ejercicios:
ATM:
Código:

25. IR
Código:

26. Empleado
Código

31. Tarea
Realizar un arreglo de estructura en el cual se incluyan los siguientes
datos:
 Nombre (personal)
 Edad (personal)
 Sexo (personal)
 Trabajo (sio no) de tipo boolean (personal)
 Parentesco (personal)
 Hobby (personal)
 Nivel académico (personal)
 Orden de mayor a menor (familiar)
 Domicilio (familiar)
 Celular (personal)
 Teléfono convencional (familiar)