Funciones en lenguaje C

Las funciones void permiten emular lo que en otros lenguajes se conoce como procedimientos (por ejemplo, en Pascal). Se utilizan cuando no es necesario devolver un valor. A continuación, se muestra un ejemplo que imprime los cuadrados de ciertos números.

void cuadrados() {
int contador;
for( contador=1; contador<10; contador++)
printf("%d\n",contador*contador);
}

main() {
cuadrados();
}

Parámetros de entrada y salida

Para usar parámetros de entrada/salida, el parámetro formal debe estar precedido por el símbolo & y el parámetro actual debe ser una variable (no una expresión cualquiera). Los parámetros de entrada/salida se usan cuando se desea que un procedimiento cambie el contenido de la variable actual. Definir estos parámetros explícitamente como variables hace que el programador sea consciente de los lugares donde un procedimiento puede modificar una variable que se le pasa como parámetro.

El funcionamiento de los parámetros de entrada/salida se basa en pasar al procedimiento una referencia a la variable actual en lugar de su valor. Por ello, a estos parámetros también se los denomina parámetros por referencia.

#include <stdio.h>
#include <conio.h>
#include<math.h>
main () {
void raices( float a, float b, float c, float &R1, float &R2 ) {
float valor;
valor = sqrt ( b * b - 4.0 * a * c );
R1 = ( -b + valor ) / ( 2.0 * a );
R2 = ( -b - valor ) / ( 2.0 * a );
}

Arreglo de Registro (STRUCT)

Un arreglo de registro es una estructura homogénea, compuesta por varios registros (estructuras), todos del mismo tipo. Se puede acceder a cada campo por el nombre del arreglo, seguido de un subíndice entre corchetes, un punto y el nombre del campo deseado.

Un struct es una forma de agrupar un conjunto de variables en una estructura. Al crear un struct, se pueden crear varias instancias de este nuevo tipo de variable.

struct Structure1 {
char c;
int i;
float f;
};

int main() {
struct Structure1 s1, s2;
s1.c = 'a'
s1.i = 1;
s1.f = 3.14;
s1.d = 0.00093;
s2.c = 'a';
s2.i = 1;
s2.f = 3.14;
s2.d = 0.00093;
}

Punteros

Un puntero es un tipo especial de variable que almacena direcciones de memoria. Una dirección de memoria especifica dónde se guarda un registro o variable en la memoria de la máquina.

Para crear un puntero que apunte a enteros, se debe hacer algo similar a declarar una variable int, pero se precede el nombre del puntero con un asterisco * para indicar al compilador que es un puntero a int y no un int en sí mismo.

int A; // variable entera
int *pA; // puntero a entero

Ficheros

C define la estructura de datos FILE en el fichero de cabecera stdio.h para el manejo de archivos. Siempre se utilizan punteros a estas estructuras.

La definición de esta estructura depende del compilador, pero en general, mantienen un campo con la posición actual de lectura/escritura, un buffer para mejorar el rendimiento de acceso al archivo y algunos campos para uso interno.

  • FILE *fopen (char *nombre, char *modo);
    Esta función sirve para abrir y crear archivos en disco. El valor de retorno es un puntero a una estructura FILE.
  • size_t fwrite (void *puntero, size_t tamaño, size t nregistros, FILE *fichero);
    Esta función está diseñada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir en un archivo uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada.
  • size_t fread (void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);
    Esta función está diseñada para trabajar con registros de longitud constante. Es capaz de leer desde un archivo 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.
  • int fclose (FILE *fichero);
    Es importante cerrar los archivos abiertos antes de salir de la aplicación. Esta función sirve para eso. Cerrar un archivo almacena los datos que aún están en el buffer de memoria y actualiza algunos datos de la cabecera del archivo que mantiene el sistema operativo. Además, permite que otros programas puedan abrir el archivo para su uso. A menudo, los archivos no pueden ser compartidos por varios programas.

Ejercicio: Mostrar un fichero 2 veces

#include <stdio.h>
int main() {
FILE *fichero;
fichero= fopen ("precio.c", "r");
while (!feof (fichero)) fputc (fgetc (fichero), stdout);
rewind(fichero);
while (!feof (fichero)) fputc (fgetc (fichero), stdout);
fclose(fichero);
getchar();
return 0;
}