Introducción

Programas

El desarrollo de un programa

Tipos básicos y variables

Funciones

Expresiones y operadores

Conversión de tipos

Control de flujo

Definición y prototipos de funciones

Construcción de tipos

Ambito de funciones y variables

Punteros

El preprocesador

Funciones de entrada y salida por pantalla

Funciones de asignación de memoria

Funciones matemáticas

Operaciones con ficheros

Bibliografía y referencias
 
 

Introducción.

C es un lenguaje de programación de propósito general que ofrece economía sintáctica, control de flujo y estructuras sencillas y un buen conjunto de operadores. No es un lenguaje de muy alto nivel y más bien un lenguaje pequeño, sencillo y no está especializado en ningún tipo de aplicación. Esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje.

Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a ningún sistema operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de programación de sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de igual forma se pueden desarrollar cualquier tipo de aplicación.

La base del C proviene del BCPL, escrito por Martin Richards, y del B escrito por Ken Thompson en 1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes sin tipos, al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece son caracteres, números enteros y en coma flotante, de varios tamaños. Además se pueden crear tipos derivados mediante la utilización de punteros, vectores, registros y uniones. El primer compilador de C fue escrito por Dennis Ritchie para un DEC PDP-11 y escribió el propio sistema operativo en C.

C trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría de computadoras actuales, como son los caracteres, números y direcciones. Estos tipos de datos pueden ser manipulados por las operaciones aritméticas que proporcionan las computadoras. No proporciona mecanismos para tratar tipos de datos que no sean los básicos, debiendo ser el programador el que los desarrolle. Esto permite que el código generado sea muy eficiente y de ahí el éxito que ha tenido como lenguaje de desarrollo de sistemas. No proporciona otros mecanismos de almacenamiento de datos que no sea el estático y no proporciona mecanismos de entrada ni salida. Ello permite que el lenguaje sea reducido y los compiladores de fácil implementación en distintos sistemas. Por contra, estas carencias se compensan mediante la inclusión de funciones de librería para realizar todas estas tareas, que normalmente dependen del sistema operativo.

Originariamente, el manual de referencia del lenguaje para el gran público fue el libro [1] de Kernighan y Ritchie, escrito en 1977. Es un libro que explica y justifica totalmente el desarrollo de aplicaciones en C, aunque en él se utilizaban construcciones, en la definición de funciones, que podían provocar confusión y errores de programación que no eran detectados por el compilador. Como los tiempos cambian y las necesidades también, en 1983 ANSI establece el comité X3J11 para que desarrolle una definición moderna y comprensible del C. El estándar está basado en el manual de referencia original de 1972 y se desarrolla con el mismo espíritu de sus creadores originales. La primera versión de estándar se publicó en 1988 y actualmente todos los compiladores utilizan la nueva definición. Una aportación muy importante de ANSI consiste en la definición de un conjunto de librerías que acompañan al compilador y de las funciones contenidas en ellas. Muchas de las operaciones comunes con el sistema operativo se realizan a través de estas funciones. Una colección de ficheros de encabezamiento, headers, en los que se definen los tipos de datos y funciones incluidas en cada librería. Los programas que utilizan estas bibliotecas para interactuar con el sistema operativo obtendrán un comportamiento equivalente en otro sistema.

Programas.

La mejor forma de aprender un lenguaje es programando con él. El programa más sencillo que se puede escribir en C es el siguiente:

	void main() { 
	}

Un programa algo más complicado es el siguiente:

	#include <stdio.h> 
	void main() { 
		printf("Hola amigos!\n"); 
	}

Las funciones de entrada y salida y los formatos utilizados los explicaremos con más detalle en otro capítulo.

El desarrollo de un programa.

Un programa C puede estar formado por diferentes módulos o fuentes. Es conveniente mantener los fuentes de un tamaño no muy grande, para que la compilación sea rápida. También, al dividirse un programa en partes, puede facilitar la legibilidad del programa y su estructuración. Los diferentes fuentes son compilados de forma separada, únicamente los fuentes que han sido modificados desde la última compilación, y después combinados con las librerías necesarias para formar el programa en su versión ejecutable.

Los comandos necesarios para compilar, linkar y ejecutar un programa dependen del sistema operativo y debemos dirigirnos a los manuales correspondientes para conocer la sintaxis exacta. Como forma más común podemos dar la siguiente:
 
 

Tipos básicos y variables.

Los tipos de datos básicos definidos por C son caracteres, números enteros y números en coma flotante. Los caracteres son representados por char, los enteros por short, int, long y los números en coma flotante por float y double. Los tipos básicos disponibles y su tamaño son:
 
 

La palabra unsigned en realidad es un modificador aplicable a tipos enteros, aunque si no se especifica un tipo se supone int. Un modificador es una palabra clave de C que indica que una variable, o función, no se comporta de la forma normal. Hay también un modificador signed, pero como los tipos son por defecto con signo, casi no se utiliza.

Las variables son definidas utilizando un identificador de tipo seguido del nombre de la variable. Veamos el siguiente programa:
 
 

Hay un tipo muy importante que se representa por void que puede significar dos cosas distintas, según su utilización. Puede significar nada, o sea que si una función devuelve un valor de tipo void no devuelve ningún resultado, o puede significar cualquier cosa, como puede ser un puntero a void es un puntero genérico a cualquier tipo de dato. Más adelante veremos su utilización.

Funciones.

Un programa C está formado por un conjunto de funciones que al menos contiene la función main. Una función se declara con el nombre de la función precedido del tipo de valor que retorna y una lista de argumentos encerrados entre paréntesis. El cuerpo de la función está formado por un conjunto de declaraciones y de sentencias comprendidas entre llaves. Veamos un ejemplo de utilización de funciones:
 
 

Todas las líneas que comienzan con el símbolo # indican una directiva del precompilador. Antes de realizar la compilación en C se llama a un precompilador cuya misión es procesar el texto y realizar ciertas sustituciones textuales. Hemos visto que la directiva #include incluye el texto contenido en un fichero en el fuente que estamos compilando. De forma parecida, #define nombre texto sustituye todas las apariciones de nombre por texto. Así, en el fuente, la palabra VALOR se sustituye por el número 5.

El valor que debe devolver una función se indica con la palabra return. La evaluación de la expresión debe dar una valor del mismo tipo de dato que el que se ha definido como resultado. La declaración de una variable puede incluir una inicialización en la misma declaración. Se debe tener muy en cuenta que en C todos los argumentos son pasados 'por valor'. No existe el concepto de paso de parámetros 'por variable' o 'por referencia'. Veamos un ejemplo:
 
 

Expresiones y operadores.

Los distintos operadores permiten formar expresiones tanto aritméticas como lógicas. Los operadores aritméticos y lógicos son:
 
 

En estos operadores deben tenerse en cuenta la precedencia de operadores y las reglas de asociatividad, que son las normales en la mayoría de lenguajes. Se debe consultar el manual de referencia para obtener una explicación detallada. Además hay toda una serie de operadores aritméticos con asignación, como pueden ser += y ^=.

En la evaluación de expresiones lógicas, los compiladores normalmente utilizan técnicas de evaluación rápida. Para decidir si una expresión lógica es cierta o falsa muchas veces no es necesario evaluarla completamente. Por ejemplo una expresión formada <exp1> || <exp2>, el compilador evalúa primero <exp1> y si es cierta, no evalúa <exp2>. Por ello se deben evitar construcciones en las que se modifiquen valores de datos en la propia expresión, pues su comportamiento puede depender de la implementación del compilador o de la optimización utilizada en una compilación o en otra. Estos son errores que se pueden cometer fácilmente en C ya que una asignación es también una expresión.

Debemos evitar:
 
 

Cuando escribimos una expresión aritmética a+b, en la cual hay variables o valores de distintos tipos, el compilador realiza determinadas conversiones antes de que evalúe la expresión. Estas conversiones pueden ser para 'aumentar' o 'disminuir' la precisión del tipo al que se convierten los elementos de la expresión. Un ejemplo claro, es la comparación de una variable de tipo int con una variable de tipo double. En este caso, la de tipo int es convertida a double para poder realizar la comparación.

Los tipos pequeños son convertidos de la forma siguiente: un tipo char se convierte a int, con el modificador signed si los caracteres son con signo, o unsigned si los caracteres son sin signo. Un unsigned char es convertido a int con los bits más altos puestos a cero. Un signed char es convertido a int con los bits más altos puestos a uno o cero, dependiendo del valor de la variable.

Para los tipos de mayor tamaño: si un operando es de tipo double, el otro es convertido a double. Si un operando es de tipo float, el otro es convertido a float. Si un operando es de tipo unsigned long, el otro es convertido a unsigned long. Si un operando es de tipo long, el otro es convertido a long. Si un operando es de tipo unsigned, el otro es convertido a unsigned. Si no, los operandos son te tipo int.

Una variable o expresión de un tipo se puede convertir explícitamente a otro tipo, anteponiéndole el tipo entre paréntesis.
 
 

La sentencia de control básica es if (<e>) then <s> else <t>. En ella se evalúa una expresión condicional y si se cumple, se ejecuta la sentencia s; si no, se ejecuta la sentencia t. La segunda parte de la condición, else <t>, es opcional.
 
 

Otras sentencias interesantes, aunque menos utilizadas son break y continue. break provoca que se termine la ejecución de una iteración o para salir de la sentencia switch, como ya hemos visto. En cambio, continue provoca que se comience una nueva iteración, evaluándose la expresión de control. Veamos dos ejemplos:
 
 

Los programas sencillos, como los ejemplo planteados hasta ahora, normalmente no necesitan un nivel de estructuración elevado. Pero cuando éstos crecen un poco necesitamos estructurarlos adecuadamente para mantenerlos legibles, facilitar su mantenimiento y para poder reutilizar ciertas porciones de código. El mecanismo C que nos permite esto son las funciones. Con los compiladores, los fabricantes nos proporcionan un conjunto importante de funciones de librería. A veces, nos puede interesar construir nuestras propias librerías. Ya hemos utilizado funciones, pero veamos cómo debemos definirlas.

Los prototipos de funciones son una característica clave de la recomendación ANSI del C. Un prototipo es una declaración que toma la forma:

tipo_resultado nombre_función ( tipo_parámetro nombre_parámetro ... );

Aquí tenemos varios ejemplos:
 
 

En la vieja definición de Kernighan y Ritchie el tipo que devolvía una función se declaraba únicamente si era distinto de int. Similarmente, los parámetros eran declarados en el cuerpo de la función, en lugar de utilizar la lista de parámetros. Por ejemplo:
 
 

En un programa que esté formado por distintas partes bien diferenciadas es conveniente utilizar múltiples ficheros fuente. Cada fuente agrupa las funciones semejantes, como por ejemplo en un compilador podríamos tener un fuente para el análisis léxico, otro para el sintáctico y otro para la generación de código. Pero en un fuente necesitaremos funciones que se han definido en otro. Para ello, escribiremos un fichero de cabecera (header), que contendrá las declaraciones que podemos necesitar en otros fuente. Así, en el fuente que implementa el analizador sintáctico pondremos una línea #include "lexic.h". De esta forma al compilar el módulo sintáctico tendremos todos los prototipos de las funciones del léxico y el compilador podrá detectar malas utilizaciones de las funciones allí definidas.

Construcción de tipos.

Los datos del mundo real, normalmente no están formados por variables escalares de tipos los tipos básicos. Por ejemplo, nos puede interesar saber cuántos módulos en C hemos escrito cada semana, a lo largo del año. O también nos interesa tener los datos de cada planeta del Sistema Solar, masa, posición, velocidad y aceleración, para un programa de simulación de la ley de gravitación de Newton. Para resolver el primer caso, C nos permite declarar una variable que sea de tipo vector. Para el segundo, podemos definir un registro para cada elemento.

Un vector es una porción de memoria que es utilizada para almacenar un grupo de elementos del mismo tipo Un vector se declara: tipo nombre [tamaño];. Por ejemplo, int modulo[52];. Aquí 'modulo' es un vector de 52 elementos enteros.
 
 

Un registro agrupa distintos tipos de datos en una misma estructura. Los registros son definidos de la forma:
 
 

A veces los datos se ajustan a series ordenadas en las cuales un elemento sigue, o precede, a otro. Un caso típico son los días de la semana. Si se desea realizar iteraciones con los días de la semana una forma es, por ejemplo, asignar un número a cada día con #define. C proporciona un mecanismo compacto para realizar esto; son las enumeraciones. Una enumeración toma la forma: enum nombre { lista de elementos };. Veamos un ejemplo:
 
 

El ámbito, o visibilidad, de una variable nos indica en que lugares del programa está activa esa variable. Hasta ahora, en los ejemplos que hemos visto, se han utilizado variables definidas en el cuerpo de funciones. Estas variables se crean en la memoria del ordenador cuando se llama a la función y se destruyen cuando la función termina de ejecutarse. Es necesario a veces, que una variable tenga un valor que pueda ser accesible desde todas las funciones de un mismo fuente, e incluso desde otros fuentes.

En C, el ámbito de las variables depende de dónde han sido declaradas y si se les ha aplicado algún modificador. Una variable definida en una función es, por defecto, una variable local. Esto es, que sólo existe y puede ser accedida dentro de la función. Para que una variable sea visible desde una función cualquiera del mismo fuente debe declararse fuera de cualquier función. Esta variable sólo será visible en las funciones definidas después de su declaración. Por esto, el lugar más común para definir las variables globales es antes de la definición de ninguna función. Por defecto, una variable global es visible desde otro fuente. Para definir que existe una variable global que está definida en otro fuente tenemos que anteponer la palabra extern a su declaración. Esta declaración únicamente indica al compilador que se hará referencia a una variable declarada en un módulo distinto al que se compila.

Las variables locales llevan implícito el modificador auto. Este indica que se crean al inicio de la ejecución de la función y se destruyen al final. En un programa sería muy ineficiente en términos de almacenamiento que se crearan todas las variables al inicio de la ejecución. Por contra, en algunos casos es deseable. Esto se consigue anteponiendo el modificador static a una variable local. Si una función necesita una variable que únicamente sea accedida por la misma función y que conserve su valor a través de sucesivas llamadas, es el caso adecuado para que sea declarada local a la función con el modificador static. El modificador static se puede aplicar también a variables globales. Una variable global es por defecto accesible desde cualquier fuente del programa. Si, por cualquier motivo, se desea que una de estas variables no se visible desde otro fuente se le debe aplicar el modificador static. Lo mismo ocurre con las funciones. Las funciones definidas en un fuente son utilizables desde cualquier otro. En este caso conviene incluir los prototipos de las funciones del otro fuente. Si no se desea que alguna función pueda ser llamada desde fuera del fuente en la que está definida se le debe anteponer el modificador static.
 
 

Otro modificador utilizado algunas veces es el register. Este modificador es aplicable únicamente a variables locales e indica al compilador que esta variable debe ser almacenada permanentemente en un registro del procesador del ordenador. Este modificador es herencia de los viejos tiempos, cuando las tecnologías de optimización de código no estaban muy desarrolladas y se debía indicar qué variable era muy utilizada en la función. Hoy en día casi todos los compiladores realizan un estudio de qué variables locales son las más adecuadas para ser almacenadas en registros, y las asignan automáticamente. Con los compiladores modernos se puede dar el caso de que una declaración register inadecuada disminuya la velocidad de ejecución de la función, en lugar de aumentarla. Por ello, hoy en día, la utilización de este modificador está en desuso, hasta el punto de que algunos compiladores lo ignoran. Se debe tener en cuenta que de una variable declarada como register no se puede obtener su dirección, ya que está almacenada en un registro y no en memoria.

Punteros.

Cada variable de un programa tiene una dirección en la memoria del ordenador. Esta dirección indica la posición del primer byte que la variable ocupa. En el caso de una estructura es la dirección del primer campo. En los ordenadores actuales la dirección de inicio se considera la dirección baja de memoria. Como en cualquier caso las variables son almacenadas ordenadamente y de una forma predecible, es posible acceder a estas y manipularlas mediante otra variables que contenga su dirección. A este tipo de variables se les denomina punteros.

Los punteros C son el tipo más potente y seguramente la otra clave del éxito del lenguaje. La primera ventaja que obtenemos de los punteros es la posibilidad que nos dan de poder tratar con datos de un tamaño arbitrario sin tener que moverlos por la memoria. Esto puede ahorrar un tiempo de computación muy importante en algunos tipos de aplicaciones. También permiten que una función reciba y cambie el valor de una variable. Recordemos que todas las funciones C únicamente aceptan parámetros por valor. Mediante un puntero a una variable podemos modificarla indirectamente desde una función cualquiera.

Un puntero se declara de la forma: tipo *nombre;
 
 

De forma similar se pueden utilizar funciones que tengan como parámetros punteros, para cambiar el valor de una variable. Veamos:
 
 

En los programas que se escriban se debe intentar evitar declaraciones complejas que dificulten la legibilidad del programa. Una forma de conseguirlo es utilizando typedef para redefinir/renombrar tipos.
 
 

El preprocesador es una parte del compilador que se ejecuta en primer lugar, cuando se compila un fuente C y que realiza unas determinadas operaciones, independientes del propio lenguaje C. Estas operaciones se realizan a nivel léxico y son la inclusión de otros textos en un punto del fuente, realizar sustituciones o eliminar ciertas partes del fuente. Debemos tener en cuenta que el preprocesador trabaja únicamente con el texto del fuente y no tiene en cuenta ningún aspecto sintáctico ni semántico del lenguaje.

El control del preprocesador se realiza mediante determinadas directivas incluidas en el fuente. Una directiva es una palabra que interpreta el preprocesador, que siempre va precedida por el símbolo # y que está situada a principio de línea.

La directiva #define se utiliza para definir una macro. Las macros proporcionan principalmente un mecanismo para la sustitución léxica. Una macro se define de la forma #define id secuencia. Cada ocurrencia de id en el fuente es sustituida por secuencia. Puede definirse una macro sin una secuencia de caracteres. Una macro se puede "indefinir" mediante la directiva #undef.
 
 

Funciones de entrada y salida por pantalla.

En este apartado y los siguientes vamos a ver algunas de las funciones más importantes que nos proporcionan las librerías definidas por ANSI y su utilización. Como hemos visto hasta ahora, el lenguaje C no proporciona ningún mecanismo de comunicación ni con el usuario ni con el sistema operativo. Ello es realizado a través de las funciones de librería proporcionadas por el compilador.

El fichero de declaraciones que normalmente más se utiliza es el stdio.h. Vamos a ver algunas funciones definidas en él.

Una función que ya hemos utilizado y que, ella y sus variantes, es la más utilizadas para la salida de información es printf. Esta permite dar formato y enviar datos a la salida estándar del sistema operativo.
 
 

Los flags pueden ser los caracteres:
 
 

En el campo width se especifica la anchura mínima de la forma:
 
 

Hay dos modificadores de tamaño, para los tipos enteros:
 
 

Otra función similar a printf pero para la entrada de datos es scanf. Esta toma los datos de la entrada estándar del sistema operativo. En este caso, la lista de argumentos debe estar formada por punteros, que indican dónde depositar los valores.
 
 

Hemos visto que en C, las variables estáticas pueden estar creadas al inicio de la ejecución del programa, o bien son variables locales automáticas que se crean al iniciarse la ejecución de una función. En muchas aplicaciones en necesario la utilización de estructuras de datos dinámicas, o bien variables que deben existir durante un tiempo no determinado a priori. Para asignar memoria de forma dinámica, C utiliza varias funciones definidas en stdlib.h. Vamos a ver la utilización de estas funciones.

La función de asignación de memoria más utilizada es malloc. Esta toma como parámetro el tamaño en bytes y devuelve un puntero al bloque de memoria asignado. Si no hay memoria suficiente para asignar el bloque devuelve NULL.
 
 

Funciones matemáticas.

La utilización de las funciones matemáticas definidas en el ANSI C requieren la inclusión del fichero math.h. Todas ellas trabajan con el tipo double, por lo que si los argumentos o resultados son del tipo float el propio compilador se encarga de convertirlos al formato adecuado. En ANSI se está trabajando para proporcionar funciones con argumentos de tipo float e introducir el tipo long float. Casi todas la funciones tienen la forma double nombre ( double x );.
 
 

Operaciones con ficheros.

La entrada y salida a ficheros es uno de los aspectos más delicados de cualquier lenguaje de programación, pues suelen estar estrechamente integradas con el sistema operativo. Los servicios ofrecidos por los sistemas operativos varían enormemente de un sistema a otro. Las librerías del C proporcionan un gran conjunto de funciones, muchas de ellas descritas en el libro de Kernighan y Ritchie y otras derivadas de los servicios que ofrece el Unix.

En C hay dos tipos de funciones de entrada/salida a ficheros. Las primeras son derivadas del SO Unix y trabajan sin buffer. Las segundas son las que fueron estandarizadas por ANSI y utilizan un buffer intermedio. Además, hacen distinciones si trabajan con ficheros binarios o de texto. Veremos las segundas, que son las más utilizadas.

Las funciones del C no hacen distinción si trabajan con un terminal, cinta o ficheros situados en un disco. Todas las operaciones se realizan a través de streams. Un stream está formado por una serie ordenada de bytes. Leer o escribir de un fichero implica leer o escribir del stream. Para realizar operaciones se debe asociar un stream con un fichero, mediante la declaración de un puntero a una estructura FILE. En esta estructura se almacena toda la información para interactuar con el SO. Este puntero es inicializado mediante la llamada a la función fopen(), para abrir un fichero.

Cuando se ejecuta todo programa desarrollado en C hay tres streams abiertos automáticamente. Estos son stdin, stdout y stderr. Normalmente estos streams trabajan con el terminal, aunque el sistema operativo permite redireccionarlos a otros dispositivos. Las funciones printf() y scanf() que hemos visto, utilizan stdout y stdin respectivamente.

Los datos de los ficheros pueden ser accedidos en uno de los dos formatos: texto o binario. Un text stream consiste en una serie de lineas de texto acabadas con un carácter newline. En modo binario un fichero es una colección de bytes sin ninguna estructura especial.

Hay que tener muy en cuenta que respecto a la velocidad de la memoria y de la CPU, los dispositivos de entrada y salida con muy lentos. Puede haber cinco o seis órdenes de magnitud entre la velocidad de la CPU y la de un disco duro. Además una operación de entrada y salida puede consumir una cantidad importante de recursos del sistema. Por ello, conviene reducir en número de lecturas y escrituras a disco. La mejor forma de realizar esto es mediante un buffer. Un buffer es una área de memoria en la cual los datos son almacenados temporalmente, antes de ser enviados a su destino. Por ejemplo, las operaciones de escritura de caracteres a un fichero se realizan sobre el buffer del stream. Unicamente cuando se llena el buffer se escriben todos los caracteres sobre el disco de una vez. Esto ahorra un buen número de operaciones sobre el disco. Las funciones del C nos permiten modificar el tamaño y comportamiento del buffer de un stream.

Para utilizar las funciones de ficheros se debe incluir el fichero stdio.h. Este define los prototipos de todas las funciones, la declaración de la estructura FILE y algunas macros y definiciones. Una definición importante es EOF, que es el valor devuelto por muchas funciones cuando se llega al final de fichero.

Los pasos a seguir para operar con un fichero son: abrir, realizar el tratamiento y cerrar. Para abrir un fichero se utiliza la función fopen. Esta toma dos strings como parámetros. El primero indica el nombre del fichero que deseamos abrir y el segundo indica el modo de acceso.
 
 

Si se desea especificar un fichero binario, se añade una b al modo: "wb+". Si el fichero se abre correctamente, la función devuelve un puntero a una estructura FILE. Si no, devuelve NULL.

La función fprintf se comporta exactamente a printf, excepto en que toma una argumento más que indica el stream por el que se debe realizar la salida. De hecho, la llamada printf("x") es equivalente a fprintf ( stdout, "x").
 
 

Una vez conocemos como abrir y cerrar ficheros, vamos a ver cómo leer y escribir en ellos. Hay funciones para trabajar con caracteres, lineas y bloques.

Las funciones que trabajan con caracteres son fgetc y fputc. La primera lee un carácter de un stream y la segunda lo estribe.
 
 

Otras funciones nos permiten realizar operaciones con ficheros de texto trabajando línea a línea.
 
 

Hay dos funciones que nos permiten trabajan en bloques. Podemos considerar un bloque como un array. Debemos especificar el tamaño de cada elemento y el número de elementos.
 
 

Hasta ahora hemos visto funciones de tratamiento de ficheros que nos van bien para realizar un tratamiento secuencial de éstos. Debemos tener en cuenta que cuando debemos realizar operaciones de entrada y de salida alternadas, se deben vaciar los buffers de los streams para que las operaciones se realicen correctamente sobre los ficheros. Esto se consigue con las funciones fflush y flushall. La primera es aplicable al stream que deseemos y la segunda vacía los buffers de todos los streams abiertos.