UNIVERSIDAD CENTROAMERICANAFacultad 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 LAGUNADocente: ELSNER BOANERGE GONZÁLEZ ORTEGA

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

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

¿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.

IdentificadoresUn 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 lenguaje3. 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

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 variableUna 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

ESCRIB

E

MEMORIA

REQUERIDA

*

RANGO

ORIENTATIVO

*

EQUIVALENCIA

EN

PSEUDOCÓDIG

O

OBSERVACIONES

Entero int 2 bytes- 32768 a

32767Entero

Uso en contadores, control de bucles etc.

Entero largo long 4 bytes- 2147483648 a

2147483647Entero

Igual que int pero admite un rango más amplio

Decimal simple float 4 bytes- 3,4·1038 a

3,4·1038Real

Hasta 6 decimales. También admite enteros

Decimal doble double 8 bytes- 1,79·10308 a

1,79·10308Real

Hasta 14 decimales. También admite enteros

Carácter char 1 bytes 0 a 255 AlfanuméricaCarácter, independiente o

parte de una cadena

Uso de variables globales y locales 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 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

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).

ConstantesUna 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.

castingconsiste 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 ConceptoUn 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]:

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 seguido3. 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

0 1 2 3 4

Estructuras de datosUna 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;

};

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 absolutochar Tipo de dato carácterCase Si se cumple un caso

Default Ninguna opción de la selectiva múltipleTypedef Crea un nuevo nombre de tipo para un tipo de

dato ya definidoFor 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 repetitivaPrintf Imprime en pantallaPuts Imprime una cadenascanf Lee una variableMain Programa principal

struct Registro o estructurareturn Regresa valor a otra función

ENTRADA SALIDAPrintf 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 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 cualquierade 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 elementossiguientes: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 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 formatoLas funciones principales que realizan la entrada y salida sin formato son:

getche() Lee un carácter del teclado, no hay que esperar hasta que se pulse la tecla <enter>. Visualiza el eco del carácter.getchar() Lee un carácter del teclado, espera hasta que se pulsa la tecla <enter>.getch() Lee un carácter del teclado, no hay que esperar que se pulse la tecla <enter>. No visualiza el eco del carácter.putchar() Imprime un carácter en la pantalla en la posición actual del cursor.gets() Lee una cadena de caracteres introducida por el teclado.puts() Imprime una cadena en la pantalla, seguida de un carácter de salto de línea.justificando a la derecha. El relleno es blanco.

archivo de acceso aleatorioLa 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 utilizarsefwrite( &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 (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";

persona.inicial = 'J';

persona.edad = 20;

persona.nota = 7.5;

cout << "La edad es " << persona.edad;

 

return 0;

}

SENTENCIAS DE CONTROLEstructura de Selección if… elseLas 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.

FOREs 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 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.

FuncionesLas 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.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.

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ón heredada de los tiempos de las cintas magnéticas. Literalmente significa "rebobinar", y hace referencia a que para volver al principio de un archivo almacenado en cinta, había que rebobinarla. Eso es lo que hace ésta función, sitúa el cursor de lectura/escritura al principio del archivo.

El parámetro es un puntero a la estructura FILE del fichero que queremos rebobinar.

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);

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 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, ...);

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: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.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.

ANEXOSEjercicios:ATM:Código:

IRCódigo:

EmpleadoCódigo

Tarea Realizar un arreglo de estructura en el cual se incluyan los siguientes datos:

Nombre (personal) Edad (personal) Sexo (personal) Trabajo (si o 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)