Ap.ndice W5. C biblioteca de funciones...En su lugar, las cadenas se tratan como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación el final de una cadena en

1

Apéndice W5

BIBLIOTECA DE FUNCIONES (ANSI C)

Esta parte es una revisión breve de la biblioteca de rutinas (funciones) y archivos include, en

tiempo de ejecución. La biblioteca de C es un conjunto funciones y macros preparadas para

utilizar y diseñadas para su uso en programas C. La biblioteca en tiempo de ejecución hace la

programación más fácil, ya que incluye una amplia variedad de tareas tales como E/S de bajo y

alto nivel, manipulación de cadenas y archivos, asignación de memoria, control de procesos,

cálculos matemáticos, etc.

A.1. PLANTILLA REFERENCIA DE ENTRADAS

Las entradas de las diferentes funciones y macros han sido normalizadas para facilidad de

manejo del lector. Las rutinas han sido clasificadas por categorías. Al comienzo de cada

categoría se hace una breve descripción de su cometido principal y se presenta una tabla con las

funciones que contiene cada categoría por orden alfabético, así como una breve síntesis de su

descripción o propósito. A continuación, por orden alfabético, se describen las rutinas de

acuerdo al siguiente modelo para cada entrada.

A.2. FUNCIONES DE ASIGNACIÓN DE MEMORIA

C almacena información en la memoria principal de la computadora por dos métodos. El

primero utiliza variables globales y locales (incluyendo arrays, cadenas y estructura); en este

caso, el almacenamiento o longitudes fija. Para cambiar el tamaño de arrays y cadenas de

caracteres se debe editar el archivo fuente y recompilar su programa. Esta información se

almacena en la pila (stack). El segundo método de almacenar información es asignar memoria a

medida que el programa lo requiera y liberar esta memoria cuando ya no se necesita; esta acción

permite utilizar la misma memoria para colas diferentes en un tiempo distinto. Este proceso de

asignar memoria se denomina asignación dinámica de memoria.

Por omisión, cada vez que se ejecuta un programa, DOS establece un segmento de 64 Kb

denominado segmento de código, que contiene su código programa. DOS establece también un

segmento de 64 Kb denominado segmento de datos. Su programa puede tener múltiples

segmentos de datos y códigos.

El segmento de datos se divide en tres regiones: datos del programa (variables estáticas y

globales), pila –stack– (variables locales y argumentos) y montón o montículo –heap.

Segmento de datos

Después de asignar partes del segmento de datos a variables estáticas y globales y a la pila, el

compilador dedica el resto del segmento de datos al montículo o heap.

C contiene un gran número de funciones para asignación dinámica de memoria, que realizan

una gran variedad de tareas: asignar y liberar memoria del montículo y de la pila, obtener

información de bloques de memoria, etc.

§ allocmen #include <dos.h>

2

int allocmen(unsigned t, unsigned * seg);

La función allocmen() establece seg para apuntar a un segmento asignado de memoria de t

párrafos (1 párrafo = 16 bytes) de largo. Si hay éxito se devuelve –1, si hay error (falta

memoria), allocmen() devuelve el tamaño en párrafos del mayor bloque disponible.

if(allocmen(size, &segadd)!= -1) printf(“Error asignación memoria \n”);

Funciones relacionadas: falloc frremem, malloc, setblock.

§ brk #include <alloc.h>

int brk( void* a)

La función brk permite modificar el «valor break» de un programa. El valor break es la dirección de la primera posición más allá del segmento de datos de un programa. Si hay éxito se

devuelve 0; en caso contrario, -1, y la variable global errnoc toma el valor ENOMEN

(insuficiente memoria).

it(brk(nuevo_break) == -1) perror(“brk ha fallado”);

Funciones relacionadas: free, farmalloc, malloc, sbrk.

§ calloc #include <stdlib> #include <alloc.h>

int *calloc(size_t n, size_t s);

Asigna memoria principal (un bloque de tamaño n.s). El bloque se borra (limpia) a 0. Si se

desea asignar un bloque mayor que 64 Kb, se debe utilizar farcalloc. Devuelve un puntero al

bloque recién asignado. Si no existe bastante espacio para el nuevo bloque o bien n o s es 0,calloc devuelve nulo.

long *buffer buffer=(long *) calloc(40, sizeof(long));

Funciones relacionadas free, malloc.

§ farcalloc #include <alloc.h>

void far *farcalloc(unsigned long n, unsigned long s);

Esta función asigna n piezas de tamaño s y las pone a 0. Un puntero al principio de la memoria

asignada se devuelve si farcalloc() tiene éxito; en caso contrario se devuelve NULL.

if(array_grande=farcalloc(20000L, sizeof (int)) “” NULL) printf(“Fallo en asignación de memoria\n”);

Funciones relacionadas: calloc, farfree, farmalloc, malloc.

3

§ farmalloc #include <alloc.h>

void far *farmalloc(unsigned long n);

Asigna n bytes de memoria far. La cantidad completa de memoria encima de la pila está

disponible para asignación por farmalloc. El tamaño del bloque puede exceder de 64 Kb.

if(bloquegrande = farmalloc(80000L) == NULL printf(“Asignación fallada\n”);

Funciones relacionadas: calloc, farfree, farcalloc, malloc.

§ farrealloc #include <alloc.h>

void far *farrealloc(void far *b, unsigned long n)

Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b, al cual se ha asignado

una longitud de n bytes.

if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULLprintf(“Fallo reasignación memoria\n”);

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

§ free #include <alloc.h> #include <stdlib.h>

vid free(void *dir_memoria);

La función free() libera un bloque de memoria. El argumento dir_memoria apunta a un

bloque de memoria previamente asignado a través de una llamada a calloc, malloc o

realloc. Después de la llamada el bloque libre está disponible para asignación.

char *cad; /* asignar memoria para cadena */ cad = (char *) malloc(50);

...free(cad); /* liberar memoria */

Funciones relacionadas: calloc, malloc, realloc

§ malloc #include <stdlib.h> #include <alloc.h>

void *malloc (size_t n);

Asigna memoria a bloques en el montículo. Devuelve un puntero, que es la dirección inicial de

la memoria asignada.

cadena = malloc(MAX_CHR)

4

Funciones relacionadas: calloc, free, realloc.

§ realloc #include <alloc.h> #include <stdlib.h>

void *realloc(void *b, size_t n);

Ajusta el tamaño de un bloque de memoria b asignado por malloc o calloc a un tamaño de

n bytes. Devuelve un puntero void al bloque de memoria reasignado.

Nuevo_buffer = realloc(viejo_buffer, long+100);

Funciones relacionadas: calloc, free, malloc.

§ sbrk #include <alloc.h>

void *sbr(int n);

Se utiliza sbrk para indicar el valor break de un proceso. El valor break es la dirección del

primer byte disponible en el segmento de datos por omisión, más allá del segmento de datos que

está siendo utilizado por los datos en el proceso.

sbrk(500);

Funciones relacionadas: brk

§ setblock #include <alloc.h>

int setblock(unsigned seg, unsigned n);

Ajusta el tamaño de un bloque de memoria asignado anteriormente por allocmen. Esta función

llama a la función 4Ah de DOS para ampliar el tamaño de un bloque de memoria previamente

asignado por allocmen. En las versiones Visual C++ la función equivalente es

_dos_setblock.

A.3. FUNCIONES DE BÚSQUEDA Y ORDENACIÓN

La mayoría de los programas requieren casi siempre alguna operación de clasificación y

búsqueda de elementos en arrays. C incluye diferentes funciones que realizan estas tareas.

§ bseaech() #include <stdlib.h>

void bsearch(const void*k, const void *b, size_t n, size_t a, int(*comparar)(const void*, (const void*));

La función bsearch realiza una búsqueda binaria en un array ordenado b, de n elementos, cada

uno de a bytes de tamaño. El argumento k apunta al valor que se está buscando. bearchdevuelve un puntero (la dirección) a la primera aparición del valor k en el array. Si no se

encuentra el valor, bsearch devuelve o.

5

El argumento comparar proporciona la dirección de una rutina que aceptará dos argumentos

elem1 y elem2, cada uno un puntero a un elemento del array. La función comparar compara

cada uno de los elementos apuntados y devuelve un valor de acuerdo con la tabla siguiente:

Valor devuelto Condición Negativo Primer elemento menor que el segundo (elem1) (elem2)

Cero Los dos elementos son idénticos.

Positivo Primer elemento mayor que el segundo.

La búsqueda binaria requiere que el array esté ordenado, por lo cual, caso de que no esté

ordenado el array, se puede utilizar la función qsort para ordenar el array antes de llamar absearch.

Funciones relacionadas: lfind, lsearch, qsort.

§ lfind #include <stdlib.h>

void * lfind(const void k, const void*b, size_t *num, size_t anchura int(*comparar)(const void*, const void*));

La función lfind() realiza una búsqueda lineal de valor de k (clave) en un array de un número

específico de elementos, cada uno de un número fijo de bytes de longitud. Al contrario que

bsearch(), el array no necesita estar ordenado. lfind() devuelve un puntero al primer

elemento del array que coincide con la clave; si la clave no existe en el array, se devuelve un o.

int comp(const void*, const void *); resultado = (char **) lfind(palabrabuscada, envp, &cuenta, sizeof(char*), comp);

Funciones relacionadas: bsearch, lsearch.

§ lsearch #include <stdlib.h>

void* lsearch(const void *k, const void *a, size_t *n, size_t = W, int(*comparar) (const void*, const void *));

La función lsearch realiza una búsqueda lineal de la clave k. El array a contiene n elementos

de anchura W. La función comparar se utiliza para comparar la clave con el elemento actual

del array. Al contrario que bsearch(), en la función lsearch() el array no tiene que estar

ordenado. lsearch() devuelve un puntero al primer elemento del array que se corresponde

con la clave. Si no existe la clave en el array, se devuelve 0 y un registro se añade al array con

un valor de k.La diferencia entre lsearch() y lfind() es que lsearch() añadirá un registro al final del

array con un valor de la clave si ese registro no se ha encontrado en el array.

Funciones relacionadas: bsearch, lfind.

§ qsort #include <stdlib.h>

void qsort(void a, size_t n, size_t w, int(*comparar) (const void*, const void*));

6

La función qsort ordena un array con un número dado de elementos utilizando el método de

ordenación rápida quicksort (creado por C.A.R. Hoare). El número de elementos de array es n

y el tamaño (en bytes) de cada elemento es w. La función comparar se utiliza para comparar un

elemento del array con la clave; devuelve los siguientes valores:

Valor devuelto Condición Negativo Primer elemento (elem1) menor que el segundo (elem2).

Cero Los dos elementos son idénticos.

Positivo Primer elemento mayor que el segundo.

Ordenar la lista de enteros y visualizar el resultado.

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

int comparar(const void*, const void *);

int numeros[10] = {4,5,7,3,12,8,6,1,0,2};

main(void){ int i;

printf(“lista original:”); for(i =0; i < 10; i++) printf(“%d”, numeros[i]); qsort(numeros,10,sizeof(int), comparar); printf(“lista ordenada:”); for(i = 0; i < 10; i++) printf(“%d”, numeros[i]); return 0;

}

/* comparar enteros */

comparar(const void *i, const void *j) { return ((int *)i) – ((int *) j) }

Funciones relacionadas: bsearch, lfind, lsearch.

A.4. FUNCIONES DE CADENA

C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan como arrays de

caracteres, cada uno de los cuales ocupa un byte. Por notación el final de una cadena en C se

representa por un byte que contiene un carácter nulo (´\0´). Las cadenas pueden ser

declaradas como arrays de caracteres.

char cad[20], cad 5[] = “Hola Mortimer”;

Acceso a las cadenas

7

A las cadenas se accede directamente a través de su índice, como en el ejemplo anterior, o bien

a través de un puntero.

char cad5[] = “Hola Mortimer”; char *p_cad5; p_cad5 = cad5;

Se puede también declarar e inicializar una cadena a la vez:

char *p_cad5 = “Hola Mortimer”;

El archivo de cabecera <string.h> contiene numerosas funciones que manipulan cadenas.

§ stpcpy #include <string.h>

char *stpcpy(char *cad1, const char *cad2);

La función stpcpy() copia una cadena en otra. Devuelve un puntero al final de la cadena

copiada. Se devuelve el valor de cad1+strlen(cad2)stpcpy(orden_dos, “DIR”); stpcpy(caad1, cad2);

Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.

§ strcat #include <string.h>

char *strcat(char *cad1, const char cad2);

strcat() concatena (añade) cad1 al final de cad2, terminando la cadena resultante con un

carácter nulo (\0).

char nombre[80] = “Bob”; char blanco[2] = “”; char ultimo[80] = “Marley”; ...strcat(nombre,blanco); /* blanco se concatena a nombre */ strcat(nombre,ultimo); /* ultimo se concatena a nombre la cadena nombre será “Bob Marley” */

Funciones relacionadas: strcpy, strdup, strncat, strncpy.

§ strchr #include <string.h>

char *strchr(const char *cad, int c);

strchr() encuentra la primera aparición de c en cad y devuelve un puntero a la primera

aparición de c en cad. Si c no se encuentra, devuelve un cero (NULL).

printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));

visualizará $85725

char *s[81] = “Esta es una cadena de prueba”;

8

char *ptr; ptr = strchr(s, á´);

el valor almacenado en ptr es un puntero a la primera aparición de á´.

§ strcmp #include <string.h>

int strcmp(const char *a, const char *b);

Compara una cadena con otra. Los resultados serían:

> 0 si a > b = 0 si a == b < 0 si a < b

i = strcmp(“MNP”, “mnp”); /* resultado < 0 */ i = strcmp(“abc”, “abc”); /* resultado = 0 */ i = strcmp(“xy”, “abc”); /* resultado > 0 */

char s1[80] “ “Mayo”; char s2[80] = “Octubre”;int j; j = strcmp(s1, s2);

Funciones relacionadas: strcmpi, stricmp, strnicmp, strncmp.

§ strcmpi #include <string.h>

int strcmpi(const char *cad1, const char * call2);

Compara una cadena con otra sin diferenciar entre mayúsculas y minúsculas y devuelve un

entero:

< 0 si cad1 < cad2 = 0 si caad1 = cad2 > 0 si cad1 > cad2

v = strcmpi(c1, c2);

Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.

§ strcoll #include <string.h>

int strcoll(const char *cad1, const char cad2);

Compara cad1 con cad2. Devuelve un valor.

< 0 si cad1 < cad2 = 0 si cad1 = cad2 > 0 si cad1 > cad2

if(strcoll(nombre1, nombre2)! = 0) exit(EXIT_FAILURE);

9

Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp, strxfrm.

§ strcpy() #include <string.h>

char *strcpy(char *cad1, const char *cad2);

strcpy() copia cad2 en cad1. Si la longitud de la cadena resultante excede el tamaño

asignado a cad1, puede producir fallos en el programa.

char *a = “Pepe Luis”; char b[12]; strcpy(b, a); puts(b);

Funciones relacionadas: strcat, strcup, strncat, strncpy.

§ strcspn #include <string.h>

size_strcspn(const char *cad1, const char *cad2);

Localiza la posición de la primera aparición en una cadena de cualquier carácter de otra cadena.

Si tiene éxito, la función strcspn devuelve el índice del primer carácter de cad1, que

pertenece al conjunto de caracteres de cad2.

primero = strcspn(“circunloquio”, “q”); /* primero = 8 */

Funciones relacionadas: strpbrk, strspn.

§ strdup #include <string.h>

char * strdup(const char *cad);

Asigna memoria y copia una cadena dada en ese espacio. En realidad, strdup() llama a

malloc para asignar suficiente memoria para contener a cad. Si falla la asignación de memoria,

strdup() devuelve un carácter nulo (NULL).Lee una cadena y hacer un duplicado.

#include <stdio.h> #include <string.h> main(){ char cad1[80], * cad1_copia; printf(“Introduzca una cadena:”); gets(cad1); cad1_copia = strdup(cad1); printf(“La cadena duplicada es:%s\n”, cad1_copia); return 0; }

§ strerror #include <string.h>

char *strerror(int errnum);

10

Obtiene el mensaje de error del sistema correspondiente al número dado en el argumento

errnum. La función strerror() obtiene el mensaje de error del sistema utilizando el valor en

la variable global errno, como el índice una tabla de errores denominadas sys_errlist, que

está declarado en el archivo de cabecera stdlib.h.

errno = 0; ptr = strerror(errno);

Funciones relacionadas: perror, _strerror.

§ _strerror #include <string.h>

char *_strerror(const char *cad);

Esta función sirve para generar un mensaje de error definido por el usuario.

printf(“%s”, _strerror(“error apertura archivo”));

Funciones relacionadas: perror, strerror.

§ stricmp #include <string.h>

it stricmp(const char *cad1, const char *cad2);

Esta función se utiliza para comparar una cadena a otra sin tener en cuenta el tamaño de las

letras. Convierte todos los caracteres alfabéticos de cad1 y cad2 en minúsculas; a

continuación, se comparan las dos cadenas y devuelve un valor entero que indica el orden

lexicográfico de cad1 con respecto a cad2.

Si cad1 = cad2 el valor de la función es cero.

Si cad1 < cad2 el valor de la función es menor que cero.

Si cad1 > cad2 el valor de la función es mayor que cero.

Resultado = stricmp(cad1, cad2),

Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.

§ strlen #include <strign.h>

size_t strlen(const char *cad);

Proporciona la longitud de una cadena cad. El carácter nulo no se incluye en la longitud; en

consecuencia, cuando reserve espacio, recuerde añadir 1 al valor devuelto por strlen.

longitud = strlen(nombre); char s[81] = “Cadena demo”; printf(“La longitud de s es:%d\n” strlen(s));

Funciones relacionadas: _fstrlen

11

§ strlwr #include <string.h>

char *strlwr(char *cad);

Convierte una cadena en letras minúsculas. La función devuelve un puntero a la cadena

convertida.

char *orden =”SALIR”; strlwr(orden); /* ahora orden = “salir” */

Funciones relacionadas: strupr, toloweer

§ strncat #include <string.h>

char *strncat(char *cad1, const char *cad2, size_t n);

La función strncat() añade los primeros n caracteres de cad2 a cad1, y termina la cadena

resultante un carácter nulo. Si cad2 es mayor que n caracteres de longitud, strncat()

truncará la cadena a la longitud de n. En otro caso, concatenará la cadena completa.

char *a = “Sierra Madre”; char *b = “de la ciudad de Monterrey”;

puts(strncat(a, b, 4)); puts(strncat(a, b));

Funciones relacionadas: strcat, strdup, strcpy, strncpy.

§ strncmp #include <string.h>

int strncmp(const char *cad1, const char *cad2, size_t n);

Compara un número especificado en caracteres de dos cadenas y devuelve un entero con un

valor.

< 0 si cad1 < cad2 = 0 si cad1 < cad2 > 0 si cad1 < cad2

char *a = “Mortimer el andaluz”; char *b = “Mortimer el mexicano”;

if((strncmp(a, b, 8)) == 0) printf( “Ambas cadenas comienzan con \Mortimer\”); else printf(“Estas cadenas no comienzan con \Morrtimer\”);

Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, strnicmp.

§ strnset #include <string.h>

char *strnset(char *cad, int c, size_t n);

12

Inicializa los caracteres de una cadena a un valor dado (blanco u otro carácter). Devuelve un

puntero a la cadena cad. El carácter c se utiliza para rellenar la cadena con ese carácter; n es el

número de posiciones de caracteres que se han de inicializar.

printf(“Introduzca una cadena:”); gets(cadena);printf(“Introducir un carácter:”); c = getche(); long = strlen(cadena)/2; strnset(cadena, c, lon);

Funciones relacionadas: strset

§ strpbrk #include <string.h>

char *strpbrk(const char *cad1, const char *cad2);

Encuentra la primera aparición en cad1 de cualquiera de los caracteres de cad2. El carácter

nulo no se incluye en la búsqueda. Si el carácter no existe se devuelve un carácter nulo (NULL).

char *s = “Mortimer L.J. Mackoy”; char *p = strpbrk(s, “L4”); puts(p); /* la salida es L.J.Mackoy */

Funciones relacionadas: strchr, strcspn

§ strrchr #include <string.h>

char *strrchr(const char *cad, int c);

Encuentra la última aparición del carácter c en cad. Devuelve un puntero a la última aparición

de c o un carácter nulo si c no está en cad.

char *nombrearch = “c: /usr/tst/libro/cap1.txt”; puts(strrchr(nombrearch, ´/´));

Funciones relacionadas: strchr

§ strrev #include <string.h>

char *strrev(char *cad);

Invierte los caracteres de la cadena cad. El carácter de terminación nulo permanece en el

mismo lugar. strrev() devuelve un puntero a la cadena inversa.

Aplicación: Invertir una cadena leída del teclado e imprimir el resultado.

#include <stdio.h> #include <string.h> main(){ char demo[80] printf(“Introduzca una cadena:”); gets(demo);

13

strrev(demo); printf(“La cadena inversa es:\n %s |\n”, demo); return 0; }

Funciones relacionadas: strcpy, strncpy.

§ strset #include <string,h>

char *strset(char *cad, int c);

Establece todos los caracteres de la cadena cad al valor de c. Termina cuando se encuentra el

primer carácter nulo. Devuelve un puntero a la cadena modificada.

char *cad = “-----”; strset (cad, ´x´); /* cad es ahora xxxxx */

Funciones relacionadas: strnset.

§ strspn #include <string.h>

sze_t strspn(const char *cad1, constchar *cad2);

Localiza la posición del primer carácter de una cadena (cad1) que no pertenece al

conjunto de caracteres de otra (cad2).

loc = strspn (cad1, blanco);

§ strstr #include <string.h>

char *strstr(const char *cad1, const char *cad2);

Localiza la primera aparición de una cadena en otra. Si tiene éxito, la función strstr devuelve

un puntero a la primera aparición de cad2 como una subcadena de cad1. Si la búsqueda falla,

se devuelve NULL.

char *s = “Mi autor favorito es Octavio Paz” char *a = “Octavio Paz”; printf( “La subcadena %s se encuentra %s \n”,a,strstr(s, a));

Funciones relacionadas: strchr, strcspn, strpbrk

§ strtok #include <string.h>

char *strtok(char *cad1, const char *cad2);

Rompe una cadena en subcadenas (token) utilizando una lista de separadores. Devuelve un

puntero a la subcadena actual y un NULL cuando se alcanza el final de la cadena.

char *s = “¿Prefiere a Verdi, o a Pucini?”; char *t = “.,!* ”; puts(strtok(s, t)); puts(strtok(NULL, “!”));

14

Funciones relacionadas: strpbrk, strcspn.

§ strxfrm #include <string.h>

size_t strxfrm(char *cad1, char *cad2, size_t n);

Convierte cad2 en cad1 basado en información específica local y con un número máximo de

caracteres a situar en cad1 de n. En el siguiente ejemplo, strxfrm transforma los tres

primeros caracteres de cad1 en los tres primeros caracteres de cad2.

char *cad1 = “abcdefg”; char *cad2 = “1234567”;

clrscr();strxfrm(cad1, cad2, 3); printf(“Transformada: %s\n”, cad1);

A.5. FUNCIONES DE CLASIFICACIÓN DE CARACTERES.

C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita determinar la categoría de

un carácter o convertir un carácter de mayúsculas en minúsculas, o viceversa. La biblioteca C

contiene funciones que pueden ser definidas como macros para estos propósitos. Las macros

están definidas en el archivo de cabecera ctype.h.Las macros de clasificación sirven para determinar qué clase de valor contiene una variable

carácter. Puede necesitar conocer esta característica para identificar ciertas clases de caracteres.

Por ejemplo, si su programa pide al usuario que teclee un número, pero el usuario teclea –en su

lugar- una letra, será preciso capturar el error. Otro caso es cuando desea imprimir un archivo, y

necesita asegurarse de que el archivo contiene sólo caracteres imprimibles, en caso de que desee

que su programa acepte caracteres de control, necesita saber cuándo pulsa el usuario un carácter

de control. En resumen, cada vez que necesite identificar el tipo de tecla que ha pulsado el

usuario, se pueden utilizar las macros de clasificación.Asimismo, existen otras funciones en el archivo ctype.h que sirven para convertir caracteres

en mayúsculas en minúsculas, y viceversa; y valores enteros en códigos ASCII.

§ isalnum #include <ctype-h>

int isalnum(int c);

La función isalnum() devuelve un cero si c es un carácter no alfanumérico y un valor distinto

de cero si el carácter es alfanumérico.

carac = getch(); if(isalnum(carac)) printf(“%c letra|digito \n”, carac); else printf(“%c no letra|digito \n”, carac);

Funciones relacionadas: isascii.

§ isalpha #include <ctype.h>

15

int isalpha(int c);

La función isalpha() verifica si un carácter es alfabético. Devuelve un valor distinto de cero

si c es un carácter alfabético, o 0 si c no es alfabético.

int c = getah() if(isalpha(c)) printf(“%c es letra\n”, c);

Funciones relacionadas: iascii.

§ isascii #include ctype.h>

int isascii(int c);

Comprueba si un carácter c es un carácter ASCII; c está en el rango 0-127. Los

caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII.

carac = getch(); if(isascii(carac)) printf(“%c es ASCII \n”, carac); else printf(“%c no es ASCII \n”, carac);

Funciones relacionadas: toascii, isalnum, isdigit,

§ iscntrl, isdigit #include <ctype.h>isgraph, islower

isprint, ispunct, isspace isupper,

isxdigit

int iscntrl(int c);int isdigit(int c);int isgraph(int c);int islower(int c);int isprint(int c);int ispunct(int c);int isspace(int c);int isupper(int c);int isxdigit(int c);

Estas macros sirven para determinar propiedades específicas de un carácter ASCII.

Macro Verifica Rango válido de valores

iscntrl Carácter de control. 0..1Fh, 7Fh

isdigit Dígito decimal. ´0´..´9´

isgraph Carácter imprimible (sin espacio). 21h a 7Eh

islower Carácter minúscula. á´..´z´´

isprint Carácter imprimible 20h..7Eh

ispunct Carácter puntuación 21h..2Fh, 3Ah..40h, 5Bh..60h, 7Bh..7Eh

16

isspace Carácter blanco. 9h..Dh 0 20h (blanco)

isupper Carácter mayúscula. Á´..´Z´

isxdigit Dígito hexadecimal. ´0´..´9´Á´..´F´á´.. f´

Cada macro (función) devuelve un valor distinto de cero si c satisface el criterio de esa macro;

en caso contrario, devuelve un cero.

if(isprint(c)) printf(“\n %c imprimible\n”, c); if(iscntrl(c)) printf(“%c es un carácter de control\”, c); if(isdigit(c)) printf(“%c es un dígito\n”, c); if(islower(c)) printf(“%c es letra minúscula\n”, c)


§ toascii #include <ctype.h>

int toascii(int c);

Esta función convierte un valor entero en un carácter ASCII válido.

C = toascii(entero);


§ _tolower,tolower #include <ctype.h>

int _tolower(int c);int tolower(int c);

Convierte un carácter mayúscula en minúscula. Utilice _tolower sólo cuando esté seguro de

que el carácter que quiere convertir es una letra mayúscula.

La función _tolower() sólo está disponible en sistemas UNIX. Por consiguiente, para

asegurar la compatibilidad utilice sólo la función tolower().

c = tolower(´S´); /* c se convierte en ´S´ */

Funciones relacionadas: iascii. _toupper, toupper.

§ _touppertouper #include <ctype.h>

int _toupper(int c);int _toupper(int c);int c; // carácter a convertir

Estas funciones convierten un carácter minúscula en mayúscula. Utilice _toupper sólo cuando

esté seguro de que el carácter que quiere convertir es una letra minúscula (rango a-z).

La macro _toupper no está disponible en ANSI C. Para asegurar la compatibilidad, utilice

siempre toupper().

17

c = toupper(´s´); /* c se convierte en ´S´ */

Funciones relacionadas: iascii, _tolower, tolower.

A.6. FUNCIONES DE CALENDARIO (FECHA Y HORA)

Las funciones de calendario (fecha y hora) permiten obtener la hora actual y, a continuación,

convertirla y almacenarla de acuerdo a sus necesidades particulares. La hora actual se toma

siempre de la hora del sistema. Las funciones de calendario están incluidas en el archivo de

cabecera time.h.

§ asctime #include <time.h>

char *asctime(const struct tm *hora);

Convierte la fecha y la hora almacenada en una estructura de tipo tm en una cadena de

caracteres. La estructura tm se define en time.h así:

struct tm { int tm_sec; /* [0,59], segundos */ int tm_min; /* [0,59], minutos */ int tm_hour; /* [0,23], horas */ int tm_mday; /* [1,31], dias del mes */ int tm_mon; /* [0,11], mes del año */

int tm_year; /* [desde 1900], año */ int tm_wday; /* [0,6], dias desde domingo */ int tm_yday; /* [0,265], numero dia año */ int tm_isdst; /* indicador hora de verano */

};

printf(“Fecha/hora es %s\n”, asctime(&reloj));

Funciones relacionadas: ctime, gmtime, clocaltime, strftime, time.

§ clock #include <time.h>

cock_t clock(void);

Calcula el tiempo empleado por el proceso llamador, es decir, el tiempo utilizado de procesador.

Devuelve un valor en ticks que ha de dividirse por la constante CLK_TCK para obtener el

tiempo transcurrido en segundos. clock_t inicio, fin; printf(“Inicio:%f\n”, clock()/CLK_TCK);

Funciones relacionadas: time

§ ctime #include <time.h>

char *ctime(const time_t *hora);

Convierte la fecha y hora almacenada como valor de tipo time_t en una cadena de caracteres

(mes día hora año\0).

18

time_t hora; hora = time(NULL); printf(“Hora actual=%s\n”, ctime(&hora));

Funciones relacionadas: asctime, strtime, time.

§ difftime #include <time.h>

double difftime(time_t hora2, time_t hora1);

Obtiene la diferencia entre dos tiempos en segundos.

time_t inicio, fin clrscrl();inicio = time(NULL); delay (5000); fin = time(NULL); printf(“Diferencia en segundos: %f\n”, difftime(inicio, fin));

Funciones relacionadas: asctime, ctime, gmtime, localtime, tzset.

§ dostounix #include <dos.h>

long dostounix(struct date *f, struct time *h);

Convierte la fecha y hora DOS (devuelta por getdate y gettime) en formato UNIX.

time_t t; struct time dos_hora; struct date dos_fecha; gatdate(&Dos_hora);gettime(&dos_fecha);t = dostounix(&dos_fecha, &dos_hora);

Funciones relacionadas: ctime, gatdate, gettime.

§ ftime #include <sys/timeb.h>

void ftime(struct timeb *ptrhora);

Obtiene la hora actual y la almacena en la estructura timeb apuntada por ptrhora.

struct timeb { long time; /* segundos desde 00:00:00 hora GMT */ short millitm; /* milisegundos */ short timezone; /* diferencia en minutos */ /* hora Greenwich y hora local */ short dstflag; /* hora de verano, ahorro de luz */ };

ftime(&hora);

19

Funciones relacionadas: time tzset.

§ getdate #include <dos.h>

void gatdate(struct date *f);

Obtiene la fecha del sistema. Los componentes se almacenan en la estructura date definida en

dos.h.

struct date { int da_year; /* año actual (1980-2099) */ char da_day; /* dia mes (1-31) */ char da_mon; /* mes (1-12) */ };

struct date fecha; getdate(&fecha);

Funciones relacionadas: dostounix, gettime, setdate, settime.

§ gettime #include <dos.h>

void gettime(struct time *t);

Obtiene la hora actual del sistema. Los componentes de la hora se almacenan en la estructura

time definida en dos.h.

struct time { unsigned char ti_min /* minutos (0-59) */ unsigned char ti_hour /* horas (0-23) */ unsigned char ti_hund /* centésimas de segundo (0-99) */

unsigned char ti_sec /* segundos (0-59) */ };

struct time hora; gettime(&hora);

Funciones relacionadas: dostounix, getdate, setdate, settime.

§ gmtime #include <dos.h>

struct tm *gmtime(const time_t *hora);

Convierte la fecha y hora en el tiempo medio de Greenwich (GMT) (año, mes, día, hora,

minutos, segundos y otros campos). Véase struct tn en asctime.

ahora = gmtime(&hoy);

Funciones relacionadas: asctime, ctime, ftime, localtime, time.

§ localtime #include <time.h>

struct tm *localtime(const time_t *hora);

20

Convierte una fecha y hora en varios campos de una estructura de tipo tm. Véase struct tm

en asctime.

tiempoactual = localtime(&ahora);

Funciones relacionadas: asctime, gmtime, time.

§ mktime #include <time.h>

time_t mktime(struct tm *h);

Convierte la hora local a un valor de calendario. Véase struct tm en asctime.

Funciones relacionadas: asctime, gmtime, localtime, time.

§ setdate #include <dos.h>

void setdate(struct date *f);

Cambia la fecha actual del sistema. Los componentes de la fecha (día, mes. Año) se especifican

en los campos de la estructura date.

struct date { int da_year; /* año actual */ char da_day; /* día mes */ char da_mon; /* mes, 1 para enero, 2... */ };

setdate(&fecha);

Funciones relacionadas: getdate,gettime, settime, dostounix.

§ settime #include <dos.h>

void settime(struct time *h);

Cambia la hora actual del sistema. Los componentes de la hora –hora, minutos y segundos- se

deben cargar en los campos apropiados de la estructura time definida en dos.h. Véase

gettime.

settime(&hora);

Funciones relacionadas: dostounix, gatdate, gettime, setdate.

§ stime #include <time.h>

int stime(time_t *t);

Establece la fecha y hora del sistema al valor contenido en la posición cuya dirección está en el

argumento t.

21

time_t horasis; horasis = time(NULL); stime(&horasis);printf(“segundos desde 1/1/70 %ld”, horasis);

Funciones relacionadas: dostounix.

§ strftime #include <time.h>

size_t strftime(char *cad, size_t maxlon, const char *formato, const struct tm *t);

Convierte un puntero en una estructura tm en una cadena cad (con una longitud máxima de n),

utilizando f para dar formato a la cadena. El formato es similar a printf().

horaseg = time(NULL); horaactual = localtime(&horaseg); strftime(buffer, 80, “%A %B %d 19%y:I:%M, horaactual);

Funciones relacionadas: asctime, ctime, gmtime, localtime, time.

§ time #include <time.h>

time_t time(time_t *h);

Proporciona el tiempo del sistema en segundos desde las 00:00:00 de 1/1/1970 tiempo GMT.

time(&hora);

§ tzset #include <time.h>

void tzset(void);

Establece las variables de entorno horarios TZ; asigna valores a las variables globales

timezone, daylight y tzname.tzset();printf(“Luz de verano = %d\n”, daylight); printf(“zona horario = %ld\n”, timezone);

Funciones relacionadas: asctime, ftime, gmtime, localtime, time.

§ unixtodos #include <time.h>

void unixtodos(long time, struct date *f, struct time *h);

Convierte a formato DOS un valor de hora en el formato UNIX.

tnixtodos(t_unix, &d_dos, ft_dos);

Funciones relacionadas: getdate, gettime, time, setdate, settime.

A.7. FUNCIONES DE CONTROL DE DIRECTORIOS

22

MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerárquico que permite al usuario

organizar sus archivos en directorios y subdirectorios. Las funciones de control de directorios en

C proporcionan las herramientas necesarias para crear, modificar, mover y eliminar directorios

desde sus programas C. Las funciones de manipulación de directorios residen en el archivo de

cabecera dir.h.

§ chdir #include <dir.h>

int chdir(const char *camino);

Cambia el directorio de trabajo actual al directorio especificado en el argumento camino. La

función devuelve un 0 si tiene éxito; en caso contrario, devuelve un valor de –1 para asignar el

error. Cuando se produce un error, la variable global errno toma el valor ENOENT (camino o

archivo no encontrado).

if(chdir(\\)) { perror(“chdir()”); exit(1); }

Funciones relacionadas: mkdir, rmdir, setdisk, system.

§ findfirst #include <dir.h>

int findfirst(const char *camino, struct ffblk *ffblk, int atrib);

Busca en un directorio de disco hasta encontrar el primer archivo cuyo nombre y atributos se

corresponden con los valores especificados. El formato de la estructura ffblk es:

struct ffblk { char ff_reserved[21]; // reservada por DOS char ff_atrib; // encontrado atributo int ff_ftime; // hora archivo int ff_date; // fecha archivo long ff_fsize; // tamaño archivo char ff_name[13]; // encontrado nombre de archivo };

La variable attrib viene definida en el archivo de cabecera <dos.h> y puede ser igual a

uno de estos valores:

FA_RDONLY Archivo de sólo lectura .

FA_HIDDEN Archivo oculto.

FA_SYSTEM Archivo del sistema. FA_LABEL Etiqueta de volumen.

FA_DIREC Directorio.

FA_ARCH Bit de archivo activado.

struct ffblk ffblk; int t; t = findfirst(“*.*”, &ffblk,0);

23

Funciones relacionadas: findnext.

§ findnext #include <dir.h>

int findnext(struct ffblk *ffblk);

findnext continúa la búsqueda de findfirst(). findnext llama a la función 4Fh de

DOS para encontrar el siguiente archivo cuyo nombre y atributos son idénticos a los dados en la

llamada a la función findfirst().

findnext(&filefinfo);

Funciones relacionadas: findfirst.

§ fnmerge #include <dir.h>

void fnmerge(char *camino, const char *u, const char *dir, const *nombrearch, const char *ext);

Crea un nombre de camino completo compuesto de una letra de la unidad (u), camino del

directorio (dir), nombre de archivo (nombrearch) y extensión del archivo (ext).

fnmerge(camino, “c:”, \\aux\\”,”demo”,”.dat”);

Funciones relacionadas: fnsplit.

§ fnsplit #include <dir.h>

void fnsplit(const char *camino, char *u, char *dir, char *nombrearch, char *ext);

Separa un nombre de camino completo en sus componentes: letra de la unidad (u), camino del

directorio, nombre del archivo y extensión del archivo (ext).

h = fnsplit(camino, unidad, dir, nomarch, ext);

Funciones relacionadas: fnmerge.

§ getcurdir #include <dir.h>

int getcurdir(int u, char *dir);

Obtiene el directorio de trabajo actual en una unidad específica. El número de la unidad (u) 0 indica la unidad actual por omisión, 1 significa unidad A, 2 unidad B, etc. La función devuelve

un cero si tiene éxito, en caso de error devuelve –1.

getcurdir(3, cuentas);

Funciones relacionadas: getcwd, getdisk.

§ getcwd #include <dir.h>

24

char *getcwd(char *camino, int numcar);

getcwd obtiene el nombre de camino completo del directorio de trabajo actual, incluyendo el

nombre de la unidad. El argumento numcar indica a getcwd el máximo número de caracteres

que el buffer camino puede contener. La función getcwd es útil para obtener el nombre del

directorio actual y guardarlo. Si su programa cambia los directorios de trabajo durante su

ejecución, puede utilizar el nombre guardado para restaurar el directorio de trabajo actual antes

de terminar.

getcwd(cuentas, 80)

Funciones relacionadas: chdir.

§ getdisk #include <dir.h>

int getdisk(void);

La función getdisk obtiene el valor entero que representa la unidad actual (0, unidad A; 1,

unidad B...)

int unidad; clscr();unidad = getdisk();

Funciones relacioandas: setdisk

§ mkdir #include <dir.h>

int mkdir(const char *camino);

Crea un directorio con un nombre de camino especificado. Funciona igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha creado con éxito o –1 si se produce un error; en

este caso, la variable global errno toma el valor EACCES (permiso denegado o ENOENT(nombre de camino no válido).

EACCES Permiso denegado

ENOENT Camino no encontrado

resultado = mkdir(“PRUEBAS”); // crea el directorio PRUEBAS

Funciones relacionadas: chdir, rmdir.

§ mktemp #include <dir.h>

char *mktemp(char *plantilla);

Crea un nombre de archivo a partir de una plantilla. Devuelve un puntero al nombre del archivo

si tiene éxito y nulo en caso de error.

mktemp(nombre);

25

§ mdir #include <dir.h>

int rmdir(const char *camino);

Elimina el directorio escrito por la variable camino, siempre que el directorio esté vacío, no sea

el directorio raíz y no sea el directorio de trabajo rmdir(); devuelve 0 si la operación de

borrado tiene éxito; si se produce un error, el valor devuelto es –1 y la variable global errno se

fija a uno de los siguientes valores:

EACCES Permiso denegado.

ENOENT Camino archivo no encontrado.

Esta función es similar a RMDIR o RD de MS-DOS.

rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS

Funciones relacionadas: chdir, mkdir.

§ searchpath #include <dir.h>

char searchpath(const char *nombre);

Busca un archivo específico en una lista de directorios, incluyendo el directorio de trabajo

actual y los definidos en la variable de entorno PATH.Si el archivo se encuentra, se devuelve un puntero al nombre del camino del archivo; en caso

contrario, se devuelve NULL.

buffer = searchpath(“BC.EXE”);

Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la variable de entorno

PATH.

buffer = searchpath(“autoexec.bat”);

Funciones relacionadas: getenv, putenv.

§ setdisk #include <dir.h>

int setdisk(int nomunidad);

Cambia a una nueva unidad por omisión. El valor de la unidad (nomunidad) es un entero.

0 Unidad A

1 B:

2 C:

3 D:

...

nuevaunidad = setdisk(3); / nueva unidad actual es C:

26

Funciones relacionadas: getdisk

B.8. FUNCIONES DE CONTROL DE PROCESOS

Un proceso es un programa ejecutable en memoria y su entorno asociado. Cada vez que se

ejecuta un programa se crea un proceso.

En resumen, un proceso es un programa que se está ejecutando por el sistema operativo. Consta

del código del programa y de datos, además de información relativa al proceso, tales como

número de archivos abiertos. Siempre que se ejecuta un programa al nivel del sistema operativo

se arranca un proceso.

Las funciones de control de proceso permiten arrancar, detener y gestionar procesos

desde dentro de un programa. La mayoría de las funciones de control se declaran en el

archivo de cabecera process.h; otros archivos de cabecera que contienen funciones de

control de proceso y del entorno son locale.h, signal.h, setjmp.h y stdlib.h.

§ abbort #include <process.h> #include <stdlib.h>

void abbort(void);

Termina la ejecución del programa actual y devuelve un código de error(3).

if (argc 1) { printf(“Faltan argumentos!\n”) abort() }

Funciones relacionadas : exit, _exit, raise, signal, spaw.

§ assert #include <assert.h>

void assert(int expresion);

Imprime un mensaje de error e interrumpe el programa si expresión es falsa (0).

assert(string != NULL; assert(*string != ´\0´); assert(strlen(string) <2);

Funciones relacionadas: abort, raise, signal.

§ atexit #include <stdlib.h>

int atexit(void(*func)(void));

Procesa la función especificada al salir.

atexit(segundo);

Funciones relacionadas: abort, exit, _exit.

27

§ exec(familia) #include <process.h>

int excel(char *camino, char *arg0,...,NULL);int execle(char *camino, char *arg0,..., *argn, NULL, char **env);

int execlp(char *camino, char *arg0, arg1,...,NULL);

int execlpe(char *camino, char *arg0,...argn, NULL, char **env);

int execv(char *camino, char argv[]);

int execve(char *camino, char argv[], char **env);

int execvp(char *camino, char *argv[]);

int execvpe(char *camino, char *argv[], char **env);

Cargan y ejecutan un proceso hijo en la memoria actualmente ocupada por su código del

programa. Las funciones exec crean un proceso hijo que carga y ejecuta el programa

especificado por el argumento camino.

execlo(“hijo.exe”, hijo.exe”, “Uno, “Dos”, NULL); execv(“hijo.exe”, argv);

Funciones relacionadas: abort, atexit, exit, _exit, fpreset, spawn.

§ exit #include stdlib.h>

void exit(int estado);

Termina un programa. Antes de terminar, se cierran todos los archivos, se escribe la salida a

través del buffer y se llama a cualquier función exit registrada. estado representa el estado de

salida del programa; 0, salida normal; distinto de cero, indica un error.

exit(0);

Funciones relacionadas: abort, atexit, éxit, exit, ´fpreset, spawn, system.

§ _exit #include <stdlib.h>

void _exit(int estado);

Termina inmediatamente el proceso actual sin hacer otras operaciones auxiliares (como cierre

de archivos).

_exit(0)

Funciones relacionadas: exit.

§ getenv #include <stdlib.n>

char *getenv(const char *nomvar);

28

Obtiene la definición de una variable de la tabla de entorno del proceso. Utiliza la variable

global environ para localizar la lista de las variables de entorno y, a continuación., busca una

entrada en la lista correspondiente a nomvar.

varlib = getenv(“LIB”);

Funciones relacionadas: putenv.

§ getpid #include <process.h>

unsigned getpid(void)

Obtiene el ID de proceso de un programa. Está disponible en sistemas UNIX.

printf(“PID:%X\n”,getpid());

Funciones relacionadas: getpsp.

§ localeconv #include <locale.h>

struct lconv *localeconv(void);

Obtiene información detallada sobre formatos monetarios y numéricos de diferentes países.

p_lconv = localeconv();

Funciones relacionadas: setlocale.

§ longjmp #include <setjmo.h>

void longjmp(jmp_buf env, int valor);

Restaura el estado de la pila y la ejecución local anteriormente grabada en env por setjmp.

Longjmp(plaza, 3);

Funciones relacionadas: setjmp.

§ perror #include <stdio.h>

void perror(const char *cadena);

Imprime un mensaje de error del sistema en el flujo stderr. El argumento cadena se imprime

primero, seguido por dos puntos, a continuación el mensaje de error correspondiente al valor

actual de la variable global errno y, finalmente, un carácter de nueva línea. Si cadena es un

puntero nulo o un puntero a una cadena nula, perror imprime sólo el mensaje de error del

sistema.

perror(“Error de cierre de archivos”);

Funciones relacionadas: _strerror, strerror.

29

§ putenv #include <stdlib.h>

int putenv(const char *cadena);

Crea nuevas variables de entorno o modifica los valores de las variables de entorno existentes.

if(putenv(argv[1] == -1)

Funciones relacionadas: getenv.

§ raise #include <signal.h>

int raise(int señal);

Envía una señal al programa en ejecución. Crea una condición de excepción correspondiente al

número señal. Existen diferentes constantes, por ejemplo, SIGABRT (terminación anormal).

printf(“prueba de raise\n”); raise(SIGABRT);

Funciones relacionadas: abort, signal.

§ setjmp #include <setjmp.h>

int setjmp(jmp_buf env);

Guarda el estado actual del programa (el entorno de la pila) antes de llamar a otra función. Este

entorno puede ser restaurado por una llamada a longjmp, realizando el efecto de un goto no

local.

if(setjmp(env) != 0) printf(“valor de longjmp\n”);

Funciones relacionadas: longjmp.

§ signal #include <signal.h>

void(*signal(int sig, (*func) (int sig[, int codigo]))) (int);

Establece tratamiento de señales de interrupción. La función signal permite a un proceso elegir

uno de los diferentes modos de manipular una señal de interrupción del sistema operativo.

signal(SIGINT, SIG_IGN);

Funciones relacionadas: abort, _control87, exit, longjmp, raise, setjmp.

§ spawn (funciones) #include <stdio.h> #include <process.h>

int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL, char **envp[]);int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL);int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL,

30

char **envp[]);int spawnv(int modo, char *camino, char *argv[]);int spawnve(int modo, char *camino, char /argv[], char *envp[]); int spawnvp(int modo, char *camino, char *argv[]);int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);

La familia de funciones spawn crea y ejecuta un nuevo proceso hijo. Debe haber memoria

suficiente para cargar y ejecutar el proceso hijo.

spawnlpe(P_WAIT, “hijo.exe”, “hijo.exe”, “spawnlpe”, buf, NULL, env);

Funciones relacionadas: exec.

A.9. FUNCIONES DE CONVERSIÓN DE DATOS

Las funciones de conversión de tipos de datos sirven para crear un puente de unión entre los dos

estilos de representación de números: la cadena de texto legible por los humanos y el formato

binario legible por las máquinas. Las funciones de conversión son ideales para convertir

argumentos de líneas de órdenes de su representación de cadena al formato interno.

§ atof() #include <math.h> #include <stdlib.h>

double atof(const char *cadena);

La función atof() convierte el argumento cadena en un valor de doble precisión. La cadena

debe tener el siguiente formato:

[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]

opcional e/E

blancos o dígitos decimales tabulaciones

La conversión termina cuando aparece el primer carácter no reconocible o cuando se encuentra

un carácter nulo (´\0´).

double x; char *cad_dbl = “200-85”; ...x = atof(cad_dbl); // convierte la cadena “200.85” a real

Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf, strtod.

§ atoi #include <stdlib.h>

int atoi (const char *cadena)

La función atoi() convierte el argumento cadena en un valor entero. La cadena debe tener el

siguiente formato:

31

[espacio en blanco][signo][ddd]

opcional

espacio o tabulación dígitos decimales

La conversión termina cuando se encuentra un carácter no reconocible (carácter nulo, ´\0´,

punto decimal o una letra). Si no puede convertir la cadena devuelve nulo.

int i; char *cad_ent =123; ...i = atoi(cad_ent); // convierte la cadena “123” al entero 123

Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.

§ atol #include <stdlib.h>

long atol(const char *cadena);

Convierte el argumento cadena en un valor entero largo. La cadena debe tener el formato:

[espacio en blanco][signo][ddd]

opcional

blancos y tabulaciónes dígitos decimales

La conversión de caracteres de la cadena hasta que se encuentre el primer carácter no

reconocible o el carácter nulo (´\0´).

long int i; char cad_ent = “9876543”; ...i = atol(cad_ent); // convierte cadena “9876543” a entero largo.

Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod, strtol, strtoul, ultoa.

§ ecvt #include <stdlib.h>

char *ecvt(double valor, int n, int *dec, int *signo);

La función ecvt() convierte un argumento de valor doble precisión en una cadena con n

dígitos. Si valor tiene más de n dígitos, los dígitos inferiores se truncan. dec es un puntero a

un entero en donde se devuelve la posición del punto decimal; signo es un puntero a un entero

donde se devuelve el signo (cero, positivo; en los restantes casos, negativo).

p_buffer = ecvt(valor, exactitud, &dec, &signo);

Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa, ltoa, ultoa.

32

§ fcvt #include <stdlib.h>

char *fcvt(double valor, int n, int *dec, int *signo);

Al igual que la función ecvt, fcvt convierte el argumento valor de doble precisión en una

cadena de n dígitos. Si el número de dígitos de valor excede a n, el exceso de dígitos se

trunca. Si hay menos dígitos que n la cadena se rellena con ceros. fcvt se diferencia de ecvt

en el modo de tratar los dígitos significativos. ecvt() busca un número total de dígitos,

mientras que fcvt() busca el número de dígitos a la derecha del puntero decimal.

cadena = fcvt(valor, extatitud, %oposición_d, &signo);

Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf, sprintf, ultoa.

§ gcvt #include <stdlib.h>

char *gcvt(double valor, int ndig, char, *buf);

La función gcvt() convierte el argumento valor de doble precisión en una cadena de

caracteres que se almacena en el buffer cuya dirección se da en el argumento buf. Se debe

asignar bastante espacio en el buffer para contener todos los dígitos de la cadena convertida y el

carácter nulo de terminación (´\0´).

gcvt(valor, digitos, cadena);

Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf, sprintf, ultoa.

§ itoa #include stdlib.h>

char *itoa(int valor, char *cad, int base);

La función itoa() convierte el argumento entero valor en una cadena de caracteres

utilizando el argumento base, como base de un sistema de numeración (2 a 36). Debe existir

bastante espacio en cad para contener 17 caracteres, itoa() devuelve un puntero a la cadena

cad.

itoa(32, buffer, 16); // buffer contensrá “20”, ya que 32 entero // equivale a 20 en hexadecimal

Funciones relacionadas: ecvt, fcvt, gcvt, ltos, printf, sprintf, ultos.

§ ltoa #include <stdlib.h>

char *ltoa(long valor, char * cad, int base);

La función ltoa() convierte el argumento entero largo valor en una cadena de caracteres que

utiliza el argumento base como base de un sistema de numeración. Como un entero largo

ocupa 32 bits en base 2, la cadena puede ocupar 33 bytes con el carácter nulo de terminación.

Debe haber bastante espacio para contener 33 bytes. ltoa() devuelve un puntero a cad.

33

long valor = 99288377L ltoa(valor, cadena, 30);

Funciones relacionadas: ecvt, fcvt, gcvt, printf, sprintf, ultoa.

§ strtod #include stdlib.h>

double strtod(const char *cad, char **p);

La función strtod() convierte la cadena cad en un valor de doble precisión. La cadena debe

tener el formato

[blanco][signo][ddd][.][exponente][signo][ddd]

+, - d, D, e, E

blanco/ dígitos decimales

tabulación

strtod() devuelve el valor de doble precisión y cero si no se produce la conversión. La

conversión se termina con el primer carácter no reconocible.

Aplicación: Convertir la cadena “843899.567” a un valor de coma flotante double.

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

main(){ double x; char *num_flt = “843899.567”: char *p;

x = strtod(num_flt, &p); printf(“x = %f\n”,x); }

Funciones relacionadas: atof, scanf, strtol, strtoul.

§ strtol #include <stdlib.h>

long strtol(const char *cad, char **p, int b);

La función strtol() convierte una cadena cad en un valor entero largo. La cadena (puede

contener hasta 33 caracteres) debe tener el formato:

[espacio en blanco][signo][0][x|X][ddd]

+, - dígitos decimales

hexadecimal blancos y tabulaciones octal

34

La conversión se termina con el primer carácter no reconocible. Si se produce un error de

desbordamiento (positivo o negativo) la variable errno se establece al valor de la macro

ERANGE.

Convertir la cadena “9876” en valor entero.

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

main(){ int base = 10; long int i; char *cad_ent = “9876”; char *ptrcad; i = strtol(cad_ent, &ptrcad, base); printf(“i = %ld\n”, i); }

Funciones relacionadas: atol, ltoa, strtoul.

§ strtoul #include <stdlib.h>

unsigned long strtoul(const char *cad, char **p, int base);

Convierte una cadena de caracteres a un entero largo sin signo en la base dada. La cadena debe

tener el formato:

[espacio en blanco][0][x|X][ddd]

dígitos decimales

octal blanco o tabulaciones hexadecimal

Si la base b es cero, strtoul utiliza el primer carácter de la cadena para determinar la base

del valor.

La cadena cad puede contener hasta 33 caracteres, excluyendo el carácter de terminación

nulo (´\0,). Si se produce un error de desbordamiento, la variable errno se pone al valor de

ERANTE.

i = strtoul(cad_ent, &ptrfin, base);

Funciones relacionadas: atol, ultoa, strtol.

§ ultoa #include <stdlib.h>

char *ultoa(unsigned long valor, char, *cad, int base);

La función ultoa() toma valor en base b (entre 2 y 36) y lo convierte en una cadena.

Devuelve el puntero al principio de cad. No devuelve código de error. cad puede contener

hasta 33 caracteres, excluyendo el carácter de terminación nulo (´\0´).

ultoa(valor, buffer, base);

35

Funciones relacionadas: itoa, ltoa.

A.10. FUNCIONES DE ENTRADA/SALIDA

Las funciones de E/S (Entrada/Salida), I/O, Input/Output) permiten leer y escribir datos entre

archivos y dispositivos. En C no hay estructuras de archivos predefinidas, todos los datos se

tratan como secuencias de bytes. La lista de funciones de E/S se han agrupado de acuerdo a las

tareas específicas que realizan:

1. Secuencias o flujos (stream).

2. Bajo nivel.

3. Consola y puertos.

Funciones de flujos (stream)

Las funciones de E/S tratan los datos como una secuencia o flujo de caracteres individuales. La

elección adecuada de las funciones disponibles permite procesar datos en tamaños y formatos

diferentes, desde caracteres independientes a estructuras de datos complejos. La E/S por

secuencia, o flujo, también proporciona acciones de taponamiento (buffering) que mejoran

significativamente el rendimiento. Para utilizar los flujos, generalmente se debe incluir el

archivo stdio.h.

§ clearerr #include <stdio.h>

void clearerr(FILE *f);

Reinicializa el indicador de error de un flujo f.

clearerr(fichen);

Funciones relacionadas: eof, feof, ferror, perror.

§ fclose, fcloseall #include <stdio.h>

int fclose(FILE *f); int fcloseall(void);

Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall) excepto stdin,

stdout y stderr. Se devuelve el número de flujos cerrados y EOF si se produce un error.

fcloseall();

Funciones relacionadas: close, fdopen, fopen.

§ fdopen #include <stdio.h>

FILE *fdopen(int handle, char *modo);

36

Abre un flujo utilizando un handle (entero devuelto por las rutinas de E/S de bajo nivel, tales

como open, creat, dup y dup2); asocia una estructura de datos FILE con el archivo

especificado por handle.

p_datos = fdopen(handle, “rb”);

Funciones relacionadas: fclose, fopen, fropen, open.

§ feof #include <stdio.h>

int feof(FILE *flujo);

Comprueba el final de archivo de un flujo.

feof(fichen);

Funciones relacionadas: clearerr, fclose, rewind.

§ ferror #include <stdio.h>

int ferror(FILE *f);

Verifica si se ha producido un error en un flujo f.

ferror(fichen);

Funciones relacionadas: clarerr, eof, feof, fopen, perror.

§ fflush #include <stdio.h>

int fflush(FILE *f);

Limpia (vacía) un flujo. Los buffers se limpian automáticamente cuando están llenos, cuando se

cierra el flujo, o cuando un programa termina normalmente sin cerrar el flujo.

fflush(fp);

Funciones relacionadas: fclose, flshall, fopen.

§ fgetc #include <stdio.h>

int fgetc(FILE * f);

Lee un carácter de la posición actual del archivo y, a continuación, incremetna esta posición.

c = fgetc(fp)

Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc, putchar.

§ fgetchar #include <stdio.h>

#int fgetchar(void);

37

Lee un carácter del archivo stdin, normalmetne el teclado.

c = fgetchar();

Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.

§ fgetpos #include <stdio.h>

int fgetpos(FILE *flujo, fpos_t *p);

Obtiene y graba la posición actual del archivo. fos_t es un tipo definido en stdio.h.

fgetpos(fp, &pos_archivo);

§ fgets #include <stdio.h>

char *fgets(char *cad, int n, FILE *f);

Lee una cadena de un flujo (hasta que se encuentra \n, o el número máximo de caracteres

especificados).

fgets(caddemo,80, fp);

Funciones relacionadas: fputs, gets, puts.

§ fileno #include <stdio.h>

int fileno(FILE *f);

Obtiene el mando o manejador (handle) del archivo asociado con un flujo.

fileno(stdin);

Funciones relacionadas: fdopen, fopen.

§ fopen #include <stdio.h>

FILE *fopen(const char *f, const char *modo);

Abre un archivo f. La cadena de caracteres modo especifica el tipo de acceso.

Modo Acción“r” Abre para lectura. “w” Abre un archivo vacío para escritura. “a” Abre para escritura al final del archivo (añadir). “r+” Abre para lectura/escritura. “w+” Abre un archivo vacío para lectura/escritura. “a+” Abre para lectura y añadir. “rb” Abre un archivo binario para lectura. “wb” Crea un archivo binario para escritura. “ab” Abre un archivo binario para añadir. “rb” Abre un archivo binario para lectura/escritura. “wb” Crea un archivo binario para la lecrtura/escritura.

38

“ab” Abre o crea un archivo binario para lectura/escritura.

if ((corriente2 = fopen(“datos”, “W+”)) == NULL printf(“el archivo..no se ha abierto \n”);

Funciones relacionadas: fclose, fcloseall, fdopen, ferror, fileno, freopen, open, setmode.

§ flushall #include stdio.h>

int flushall(void);

Vacía (limpia) todos los buffers asociados con los archivos abiertos.

numvaciados = flushall();

Funciones relacionadas: fclose, fflush.

§ fprintf #include <stdio.h>

int fprintf(FILE *f, const char *formato[arg,...]);

Imprime datos con formato en un flujo.

fprintf(f1,”El resultado es %f\n”,result);

Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.

§ fputc #include <stdio.h>

int fputc(int c, FILE *f);

Escribe un carácter c en el flujo abierto para salida con buffer.

fputc(*(p++), stdout);

Funciones relacionadas: fgetc, fgetchar, fputchar, getc, getchar, putc.

§ fputchar #include <stdio.h>

int fputchar(int c);

Escribe el carácter c en stdout.

Fputchar(´q´);

Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.

§ fputs #include <stdio.h>

39

int fputs(const char *cad, FILE *f);

Escribe una letra cad en un flujo f. Devuelve el último carácter impreso, si hay error devuelve

EOF.

fputs(“esto es una prueba”, f1);

Funciones relacionadas fgets, gets, puts.

§ fread #include <stdio.h>

size_t fread(void *p, size_t t, size_t n, FILE *f);

Lee n registros de t bytes en la memoria apuntada por p desde el flujo f.

fread(buf, strlen(msg)+1, 1, flujo);

Funciones relacionadas: fwrite, read.

§ freopen #include <stdio.h>

FILE *freopen(const char *f, const char *m, FILE *flujo);

Cierra el archivo asociado con flujo y reasigna flujo al archivo especificado por f. Los modos

(m) utilizados son los mismos de fopen.

freopen(“salida.txt”, “w”, stdout);

Funciones relacionadas: fclose, fopen.

§ fscanf #include <stdio.h>

int fscanf(FILE *f, const char *formato, dirección,...);

Lee datos con formato de un flujo.

fscanf(flujo, “%s%f”, cad, &f);

Funciones relacionadas: csanf, fprintf, scanf, sscanf.

§ fseek #include <stdio.h>

int fseek(FILE *f, long desp, int org);

Mueve el puntero del archivo asociado con f a una nueva posición que está desplazada desp

bytes de org.

Origen Significado

SEEK_SET Principio de archivo.

SEEK_CUR Posición actual puntero archivo.

SEK_END Final de archivo.

40

fseek(f1,OL,SEEK_SET); // ir al principio

Funciones relacionadas: ftell, rewind, fopen.

§ fsetpos #include <stdio.h>

int fsetpos(FILE *f, const fpos_t *p);

Establece la posición del puntero del archivo al lugar especificado por el objeto apuntado por p.

fsetpos(fp, &posarch);

Funciones relacionadas: getpos.

§ ftell #include <stdio.h>

long int ftell(FILE *f);

Obtiene la posición actual (puntero) del archivo asociado con el flujo f.

ftell(fichen);

Funciones relacionadas: fgetpos, fssek, tell.

§ fwrite #include <stdio.h>

size_t fwrite(const void *p, size_t l, size_t n, FILE *f);

Escribe n elementos (registros) de longitud l desde la memoria apuntada por p al archivo f.Devuelve el número de caracteres realmente escritos que, si la función tiene éxito, es igual al

número pedido.

num = fwrite(lista, sizeof(char),25,flujo);

Funciones relacionadas: fread, write.

§ getc #include <stdio.h>

int getc(FILE *f);

Devuelve el siguiente carácter de un flujo de entrada dado e incrementa la posición actual del

puntero del archivo. Si se alcanza el final de archivo se devuelve EOF.

whilec(c = getc(fx)!= EOF) { printf(“%c”, c); }

Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc, putchar.

§ getch #include <stdio.h>

int getch(void)

41

Lee un carácter del teclado sin hacer eco en la pantalla.

do { car = getch(); char = toupper(car); } while(car != ´S´);

Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.

§ getchar #include <stdio.h>

int getchar(void);

Devuelve el siguiente carácter de stdin. Si se alcanza el final de archivo se devuelve EOF.

int c; while((c = getchar())!= ´\n´) printf(“%c”, c);

Funciones relacionadas:fgetc, fgetchar, getch, getche, putc, putchar, ungetc.

§ getche #include <stdio.h>

int getche(void);

Lee un carácter del teclado haciendo eco del carácter en la pantalla

resp= getche();

Funciones relacionadas: cgets, getch, getchar, ungetch.

§ gets #include <stdio.h>

char * gets(char *cad);

Le una línea desde el archivo de entrada estándar stdin, por omisión es el teclado y lo guarda

en cad.

gets(nombre);

Funciones relacionadas: fgets, fputs, puts.

§ getw #include <sdio.h>

int getw(FILE *f);

Lee un entero (o una palabra e dos bytes) de un flujo f.

suma = getw(fx) + suma;

Funciones relacionadas: fread, putw

42

§ printf #include <stdio.h>

int printf(const char *formato[,argumento,...]);

Escribe cadenas de caracteres y valores de variables, con formato, en el archivo de salida

estándar stdout (por omisión, la pantalla).

Códig

o

Formato

%c Carácter.

%d Entero decimal.

%e Real (double o float), notación científica.

%f Coma flotante.

%s Cadena de caracteres.

%x Hexadecimal sin signo.

printf(“producto %d y %d es %d\n”,x,y, x*y);

Funciones relacionadas: fprintf, scanf, sprintf, viprintf, vprintf, vsprintf.

§ putc, putchar #include <stdio.h>

int putc(int c, FILE *f);int putchar(int c);

Escribe un carácter en un flujo (putc) o en stdout (putchar).

putc(´*´, demo);

Funciones relacionadas: fputc, fputchar, getc, getchar.

§ putch #include <stdio.h>

int putch(int c);

Escribe un carácter en la pantalla.

putch(´B´);

Funciones relacionadas: putc, putchar.

§ puts #include <stdio.h>

int puts(const char *cad);

Escribe una cadena en el archivo de salida estándar stdout.

puts(“Desea continuar(s/n?”);

43

Funciones relacionadas: fgets, fputs, gets.

§ putw #include <stdio.h>

int putw(int i, FILE *f);

Escribe un entero en un flujo f.putw(100, fx);

Funciones relacionadas: getw, printf.

§ rewind #include <stdio.h>

void rewind(FILE *f);

Reiniciliza el puntero del archivo al principio de un flujo.

rewind(fx);

Funciones relacionadas: fseek.

§ scanf #include <stdio.h>

int scanf(const char *formato[,dirección,...]);

Lee datos con formato del flujo de entrada estándar.

Código Formato

%c Carácter.

%d Entero decimal.

%x Hexadecimal.

%i Entero decimal.

%f Número real.

%o Octal.

%p Puntero.

%s Cadena.

scanf(“%d %f %c %s”, &i, &fp, &c, s);

Funciones relacionadas:fscanf, printf, sscanf, vfprintf, vprintf, vsprintf

§ setbuf #include <stdio.h>

void setbuf(FILE *f, char *buffer);

Asigna un buffer a un flujo.

setbuf(fx, buffer);

Funciones relacionadas: setvbuf.

44

§ setvbuf #include <stdio.h>

int setvbuf(FILE *f, char *b, int t, size_t l);

Asigna el buffer b de tamaño l y el tipo t con el flujo (archivo) f. Los valores correctos de t son:

_IOBF, _IONBF, e _IOLBF.

setvbuf(demo, buffer, _IOFBF, 120);

Funciones relacionadas: setbuf.

§ sprintf #include <stdio.h>

int sprintf(char *b, const char *f[,arg,...]);

Escribe datos con formato en una cadena. Se diferencia de printf en que la salida generada se

sitúa en el array apuntado por b.

sprintf(cad, “&s %d %c”, “uno”,5,´7´);

Funciones relacionadas: sprintf, printf, vprintf, vfprintf, vsprintf.

§ sscanf #include <stdio.h>

int sscanf(const char *b, const char *f[,dirección,...]);

Esta función es idéntica a scanf, excepto que los datos son leídos del array apuntado por b, en

vez de stdin.

sscanf(buffer, “%,s%s”,uno,dos,tres);

Funciones relacionadas: cscanf, fscanf, scanf, vscanf.

§ tmpfile #include <stdio.h>

FILE *tmpfile(void);

Crea un archivo temporal y devuelve un puntero a ese flujo.

if((aux = tmpfile()) == NULL)...

Funciones relacionadas: tmpnam.

§ tmpnam #include <stdio.h>

char *tmpnam(char *s);

Genera un único nombre de archivo y lo guarda en el array apuntado por s.

tmpnam(prueba);

Funciones relacionadas: tmpfile.

45

§ ungetc #include <stdio.h>

int ungetc(int c, FILE *f);

Sitúa un carácter, excepto la constante EOF, en el buffer asociado con un archivo abierto para

entrada con buffer.

ungetc(car, stdin);

Funciones relacionadas: getc.

§ ungetch #include <stdio.h>

int ungetch(int ch);

Empuja un carácter en la memoria intermedia del teclado.

char ch; ch = getch(); ungetch(ch);

§ vfprintf, #include <stdio.h> vprintf, #include <stdarg.h> vsprintf

int vfprintf(FILE *f, const char *f, lista_va lista_arg);int vprintf(const char *f, lista_va lista_arg);int vsprintf(char *b, const char *f, lista_va lista_arg);

Escribe salida con formato utilizando un puntero a una lista de argumetnos.

vprintf(formato, nota);

Funciones relacionadas:fprintf, printf, sprintf, va_arg, va_end, va_strat.

§ vfscanf #include <stdio.h> #include <stdarg.h>

int vfscanf(FILE *F, const char *f, lista_va lista_arg);

Lee entrada con formato de un flujo, tal como scanf, excepto que vfscanf acepta un puntero

a la lista de argumentos.

vfscanf(demo, formato, arg);

Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf.

§ vscanf #include <stdio.h>

int vscanf(const char *f, lista_va lista_arg);

46

Lee una entrada con formato de un flujo; similar a scanf, excepto que vscanf acepta un

puntero a la lista de argumentos.

vscanf(formato, argumento);

Funciones relacionadas: fscanf, scanf, sscanf, fsca.

§ vsscanf #include <stdio.h> #include <stdarg.h>

int vsscanf(const char *b, const char *f, lista_va lista_arg);

Funciona igual que sscanf, excepto que en vsscanf es utilizada un puntero a una lista de

variables en lugar en lugar de a las propias variables.

vsscanf(buf_en, formato_p, arg_p);

Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.

Funciones de bajo nivel

Las declaraciones de las funciones de bajo nivel se incluyen en los archivos de cabecera io.h,

fcntl.h, sys|types.h y sys|sta.h. A diferencia de las funciones stream, las funciones

de bajo nivel no requieren el archivo de inclusión stdio.h.

§ _close, close #include <io.h>

int _close(int h);int close(int h);

Cierra el archivo especificado en h. Estas funciones se utilizan con _open y open.

close(f1);

Funciones relacionadas: fclose, fopen, open.

§ _creat #include <io.h> creat #include <sys\stat.h> #include <dos.h>

int creat(const char *cam, int modo);int _creat(const char *cam, int atributo);

Crea un nuevo archivo o abre y trunca un archivo existente. _creat() actúa igual que

creat(), excepto que utiliza un byte de atributo del DOS.

47

Modo Significado

S_IWRITE Permiso de escritura.

S_IREAD Permiso de lectura.

S_IREAD|S_IWRITE

Permiso de lectura y escritura.

fh= creat(“datos”,S_IREAD|S_IWRITE);

Funciones relacionadas: chmod, close, open umask.

§ creatnew #include <io.h> #include <dos.h>

int creatnew(const char *camino, int atributo);

Crea un archivo nuevo con los atributos especificados.

h = creatnew(“F.FIL”,0);

Funciones relacionadas: _creat, fopen, open.

§ creattemp #include <io.h> #include <dos.h>

int creattemp(char *camino, int atributo);

Crea un único archivo temporal con byte de atributo en el directorio escrito por camino.

if((h = creattemp(“nombre”,9))== -1

Funciones relacionadas: tmpfile.

§ dup, dup2 #include <io.h>

int dup(int h);int dup2(int h1, int h2);

Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace de archivo (dup2).

viejostdout = dup(STDOUT); dup2(fptr, STDOUT);

Funciones relacionadas: close, creat, open.

§ eof #include <io.h>

int eof(int d);

Comprueba si el archivo especificado en el descriptor d es el final de archivo (se devuelve 1 si

se alcanza el final del archivo. 0 si no se alcanza el final del archivo, -1 indica un error y errno

toma valor EBADF: número de archivo incorrecto).

48

while(!eof(fx))

Funciones relacionadas: feof, ferror, perror.

§ lseek #include <io.h> #include <stdio.h>

long lseek(int d, long desp, int origen);

La función lseek mueve el puntero asociado con el descriptor d a una nueva posición que está

emplazada desp bytes de origen.pos = lseek(fh, OL, SEEK_CUR);

Funciones relacionadas: fseek, tell.

§ open #include <fcntl.h> #include <io.h> #include <sys\stat.h>

int open(const char *f, int a[, unisgned m]);

Abre el archivo especificado en f para lectura o escritura. El argumento a indica el tipo de

operación permitida y m el tipo de permiso.

IndicadorLectura/escritura

Significado

O_RDONLY Abrir para lectura.

O_WRONLY Abrir para escritura.

O_RDWR Abrir para lectura y escritura.

O_NDELAY Pone el puntero del archivo al final del archivo.

O_APPEND Se crea el archivo y se fijan atributos del archivo.

O_TRUNC Trunca el archivo a 0.

O_EXCL Se utiliza con O_CREAT.

O_BINARY Abrir archivo en modo binario.

O_TEXT Abrir archivo en modo texto.

open(“OPEN.OUT”, 0_WRONLY|O_CREAT, S_IREAD|IWRITE); if((h = open(“open.tst”, O_CREAT))==1)...

Funciones relacionadas: access, chmod, close, creat, fopen.

§ sopen #include <fcntl.h> #include <io.h> #include <share.h> #include <sys/stat.h>

int sopen(char *f, int a, int s[, int m]);

Abre un archivo f con acceso a en modo compartido en un entorno de red y con el tipo s de

compartición permitido en el archivo y modo m.

49

Indicadores y permisos Significado

O_RDONLY Abrir para lectura.

O_WRONLY Abrir para escritura.

O_RDWR Abrir para lectura y escritura.

S_IWRITE Acceso de escritura.

S_IREAD Acceso de lectura.

S_IWRITE|S_IREAD Acceso de lectura y escritura.

df = sopen(“C:||autoexec.bat”, O_RDONLY, SH_DENYRW, S_IREAD);

Funciones relacionadas: close, fopen.

§ read #include <io.h>

int read (int d, void * buffer, unsigned lon);

Lee lon bytes del archivo asociado con d en el buffer apuntado por buffer.

read(fx, buffer, 100);

§ tell #include <io.h>

long tell(int d);

Devuelve la posición actual del puntero del archivo especificado por d.

posi = tell(desf);

Funciones relacionadas: ftell, lseek.

§ write #include <io.h>

int write(int d, void *buffer, unsigned lon);

Escribe datos en un archivo (lon bytes en el archivo asociado con d desde el buffer apuntado

por buffer).

write(fx, grande, 60000);

Funciones relacionadas: creat, open, read, sopen.

Funciones de consola y puertos de E/S

Las funciones de E/S sirven para interactuar con el teclado y la pantalla. Estas funciones se

declaran en el archivo de cabecera conio.h.

§ cgets #include <conio.h>

50

char *cgets(char *cadena);

Lee una cadena de caracteres directamente de la consola, y almacena la cadena y su longitud en

la posición apuntada por cadena.

entrada = cgets(cadena);

Funciones relacionadas: cputs, getch, getche.

§ cprintf #include <conio.h>

int cprintf(const char *formato[,arg,...]);

Escribe salida con formato directamente en la consola. Observe que cprintf no traduce el

carácter (\n) a una combinación (CR-LF), en su lugar, \n se interpreta como avance de línea

(LF) y \r se debe utilizar para indicar un retorno de carro (CR).

cprintf(“Cubo de %2d es %rd\r\n”,i, i * i * i);

Funciones relacionadas: printf.

§ cputs #include <conio.h>

int cputs(const char *cad);

Escribe una cadena en la pantalla. No se envía ningún carácter de nueva línea después de la cadena.

cuts(“Está usted seguro(s/n)?”);

Funciones relacionadas cprintf.

§ cscanf #include <conio.h>

int cscanf(char *formato [,dirección,...]);

Lee caracteres con formato directamente desde la consola en la posición dada por dirección.

cscanf(“%d%d%d, &dia, &mes, &hora);

Funciones relacionadas: fscanf, scanf, sscanf.

§ get, getche #include <conio.h>

int getch(void); int getche(void);

Lee un carácter de la consola sin eco (getch) o con eco (getche).

printf(“Pulse cualquier tecla para salir”);

getch();

51

Funciones relacionadas: cgets, getchar, ungetch.

§ getpass #include <conio.h>

char *getpass(const char *indicador);

Lee una palabra de paso por consola, que no se visualiza en pantalla (menos de ocho caracteres

de longitud.

palabrapaso = getpass(“Introduzca clave”);

Funciones relacionadas: getch

§ inport, inportb #include <dos.h>

int inport(int puerto);unsigned char inportb(int puerto);

Lee una palabra de 16 bits (inport) o un byte (inportb) de un puerto de E/S especificado por

puerto.

La función inport es útil para leer dos puertos adyacentes a la vez, e inportb para

controlar dispositivos de entrada/salida.

palabra = inport(PORT_8259_20); P21 = inportb(PORT_8259_21);

Funciones relacionadas: outport, poutportb.

§ kbhit #include <conio.h>

int kbhit(void);

Comprueba si se ha pulsado recientemente una tecla.

// visualizar hasta que pulsa una tecla while(!kbhit()) cputs(“Pulse una tecla”);

Funciones relacionadas: getch, getche.

§ outport, outportb #include <conio.h>

void outport(int puerto, int palabra);void outportb(int puerto, unsigned char byte);

Escribe una palabra de 16 bits (outport) un byte (outportb) en un puerto de E/S.

outport(23,0); // 23 fuera del puerto outport(Á´, 0) // A fuera de puerto

Funciones relacionadas: inp, inport, inportb, inpw.

52

§ putch #include <conio.h>

int putch(int c);

Escribe un carácter en la consola (sin acción del buffer).

putch(car); putch(´\n´); putch(´\n´);


§ ungetch #include <conio.h>

int ungetch(int c);

Sitúa un carácter en el buffer del teclado de modo que es el siguiente carácter leído en la

consola.

if(c =!EOF) ungetch(c);ungetch(car);


A.11. FUNCIONES DE GESTIÓN DE ARCHIVOS

El sistema de archivos es un componente clave del PC. Todas las aplicaciones y datos residen

en archivos. Las funciones de gestión de archivos permiten establecer y verificar permisos de

acceso a archivos. La mayoría de las funciones están en el archivo de cabecera io.h, y las

restantes en sys|stat.h, dir.h y stdio.h.

§ access #include <io.h>

int access(const char *nomarch, int modo);

Verifica si existe un archivo y, en caso afirmativo, los permisos de acceso al archivo.

Modo Significado

00 Se verifica existencia del archivo.

01 Ejecutar.

02 Verifica permiso de escritura.

04 Verifica permiso de lectura.

06 Verifica permiso de lectura y escritura.

return(access(nombre, 4)==-1)

Funciones relacionadas: chmod, fstat, stat.

§ chmod #include <stdio.h> #include <sys\stat.h>

int chmod(const char *camino, int pmodo);

53

Cambia los permisos de lectura/escritura de un archivo.

r = chmod(“prueba.tst”, S_IREAD);

Funciones relacionadas: access, fstat, stat.

pmodo Permiso de acceso

S_IWRITE Escritura. S_IREAD Lectura.S_IREAD|S_IWRITE Lectura/Escritura.

§ chsize #include <io.h>

int chsize(int manejador, long longitud);

Cambia el tamaño del archivo.

chsize(fh, 5);

Funciones relacionadas: access, chmod, fstat, stat.

§ filelength #include <io.h>

long filelenght(int manejador);

Obtiene la longitud de un archivo en bytes.

filelength(fh);

Funciones relacionadas: fileno, filestat, stat.

§ fnmerge #include <dir.h>

void fnmerge(char *camino, const char *unidad, const char *dir, const char *nombref, const char *ext);

Crea un nombre de camino completo (letra, unidad, camino directorio, nombre de archivo y

extensión del archivo). En Microsoft, la función equivalente es _makepath.

fnmerge(camino,”C:”,\\aux,”resultado”,”.dat”); // nombre de camino”C:\aux\resultado.dat”

Funciones relacionadas: fnsplit.

§ fnsplit #include <dir.h>

int fnsplit(const char *camino, char *unidad, char *dir, char *fnombre, char *ext);

Separa un nombre de camino completo en sus componentes: letra, unidad, camino, nombre y

extensión del archivo.

54

f = fnsplit(c, unidad, dir, arch, ext);

Funciones relacionadas: fnmerge.

§ fstat #include <sys\stat.h>

int fstat(int h, struct stat *buffer);

Devuelve información sobre el archivo especificado en la estructura de tipo stat apuntada por

buffer. La estructura stat es:

struct stat { short st_dev; // unidad o dispositivo short st_ino; // número inodo (UNIX) short st_mode // modo archivo short st_nlink; // número enlaces (DOS,1) int st_uid; // id de usuario (UNIX) int st_gid; // id de grupo (sólo UNIX) int st_rdev; // dispositivo UNIX long st_size; // tamaño archivo en bytes long st_atime; // hora último acceso long st_mtime; // hora última (UNIX) long st_ctime; // hora creación };

fstat(fich, &info);

Funciones relacionadas: access, chmod, stat.

§ isatty #include <io.h>

int isatty(int h);

Determina si es un dispositivo orientado a carácter (terminal, consola, impresora o puerto serie).

if(isatty(fileno(stdout))) puts(“es consola”);

§ lock #include <io.h>

int lock(int h, long d, long n);

Bloquea un número de bytes n del archivo h (manejador) con desplazamiento se utiliza para

compartición de archivos (orden SHARE de MS-DOS). En Microsoft C la función equivalente

es locking.

res lock(h, 0L,256); bloque de 256 bytes

Funciones relacionadas: sopen, unlock.

§ mktemp #include <dir.h>

char * mktemp(char *plantilla);

55

Crea un único nombre de archivo modificando una plantilla dada como argumento, plantilla

toma la forma basexxxxxx, donde base es el nombre que se proporciona y x los caracteres a

modificar.

char modelo = “tcbxxxxxx”; mktemp(modelo);

Funciones relacionadas: tmpfile, tmpnam.

§ remove #include <stdio.h>

int remove(const char *camino);

Borra el archivo especificado en camino.

remove(“C:\\ux\\demo”); // borra demo

Funciones relacionadas: unlink.

§ rename #include <stdio.h>

int rename(const char *vn, const char *nn);

Renombre el archivo vn a nn.

int resultado; resultado = rename(viejo, nuevo);

Funciones relacionadas: creat, fopen, open.

§ setmode #include <io.h> #include <fcntl.h>

int setmode(int h, int modo);

Permite cambiar el modo del archivo abierto entre texto y binario.

modo 0_BINARY(binario) 0_TEXT(texto) setmode(fileno(stdin), 0_BINARY); // modo binario

Funciones relacionadas: fopen, open.

§ stat #include <sys\stat.h>

int stat(char *f, struct stat *buffer);

Obtiene información sobre el estado de un archivo existente f.

resultado = stat(“stat.c”,&buf);

56

Funciones relacionadas: access, chmod, fstat.

§ umask #include <io.h>

unsigned umask(unsigned Pmodo);

Establece la máscara de permisos de lectura/escritura usados por open y create.

Pmpdo S_IREAD (sólo lectura) S_IWRITE (sólo escritura) S_IREAD|S_IWRITE (lectura/escritura) viejamascara = umask(S_IWRITE);

Funciones relacionadas: chmod, creat, mkdir, open, sopen.

§ unlink #include <dos.h> #include <io.h> #include <stdio.h>

int unlink(const char *camino);

Borra un archivo especificado en camino, que no sea de sólo lectura.

result = unlink(“demo.jnk”); if(result==0) printf(“unlink tuvo éxito”);

Funciones relacionadas: remove.

§ unlock #include <conio.h>

int unlock(int h, long o, long l);

Desbloquea una sección del archivo h que ha sido bloqueada con lock.

unlock(m,OL,256); // desbloquea 256 bytes

Funciones relacionadas: lock, sopen.

A.11. FUNCIONES MATEMÁTICAS

El C original de K&R fue diseñado, inicialmente, como un lenguaje de programación de

sistemas, su uso ha sido muy escaso en el campo del cálculo científico. Sin embargo, desde la

normalización de ANSI C y su extensa biblioteca matemática, C se ha convertido en un fuerte

rival del lenguaje científico por excelencia, FORTRAN. C soporta operaciones de coma flotante

e incluye también un rico conjunto de funciones matemáticas.

Los archivos de cabecera que contienen funciones matemáticas son: bcd.h, complex.h,

float.h, math.h, stdlib.h. Las funciones no incluidas en ANSI C son: _clear87, _control87, _fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min,

poly, pow10, random, randomize, _rotl, _rotr, _status87.

57

§ abs versión real #include <math.h> #include <stdlib.h>

int abs (int x);

Proporciona el valor absoluto de un entero o de un número complejo: abs(-50) devuelve 50.

Para utilizar números complejos se requiere el archivo de cabecera complex.h.

x = abs(-7) // x es 7

Funciones relacionadas: cabs, fabs, labs.

§ acos #include <math.h>

double acos(double x);

La función acos() devuelve el arco coseno de x, cuyo valor debe estar en el rango –1 a 1. El

resultado es un valor (ángulo) entre 0 y p radianes.

angulo = acos(0.5); // el ángulo devuelto es p/3

Funciones relacionadas: cos, matherr.

§ asin versión real #include <math.h>

double asin(double x);

Calcula el arco seno del argumento x; el valor de x debe estar comprendido entre –1 y 1. La

función asin() devuelve un valor entre -p/2 y p, el valor de x debe ser en radianes.

Z = asin(0.7543);

Funciones relacionadas: matherr, sin.

§ atan #include <math.h>

double atan(double x);

Calcula el arco tangente de x. El rango x es –1 a 1. La función atan() devuelve un valor en el

rango de -p/2 a p/2.

angulo = atan(1.0); // ángulo es “Pi/4” (45 grados)

Funciones relacionadas: atan2.

§ atan2 #include <math.h>

double atan2 (double y, double x);

58

Calcula el arco tangente de y/x. El resultado es un ángulo de valor comprendido entre -p y pradianes.

angulo = atan2(y, x);

Funciones relacionadas: atan, matherr, tan.

§ ceil #include <math.h>

double ceil (double x);

Calcula (redondea) el número entero mayor que o igual a x.

redondeo = ceil(5.1) // redondeo es 6

Funciones relacionadas: floor.

§ _clear87 #include <float.h>

unsigned int _clear87(void);

Borra (limpia) la palabra del estado de coma flotante.

estado = _clear87();

Funciones relacionadas: _control87, _status87.

§ _control87 #include <float.h>

unsigned int _control87(unsigned int nuevo, unsigned int mascara);

Obtiene y establece la palabra de control de coma flotante. Cuando se utiliza un coprocesador

matemático 8087, _control87 establece su palabra de control.

estado = control87(PC24,MCW_IC);// precisión 24 bits

Funciones relacionadas: _clear87, _status87.

§ cos #include <math.h>

double cos(double x);complex cos(complex x);

Calcula el coseno del argumento x. El argumento x se especifica en radianes y devuelve un

valor en el rango de –1 a 1.

coseno_x = cos(1.6543);

Funciones relacionadas: acos, sin.

59

§ cosh #include <math.h>

double cosh(double x);

Calcula el coseno hiperbólico de la variable x. Si el argumento pasado a cosh() es demasiado

grande, se produce un error de rango.

x = 1.00 printf(“x = %f.\n\n”,x); y = cosh(x); printf(“coseno hiperbólico x = %f.\n\n”, y);

Funciones relacionadas: sinh.

§ div #include <stdlib.h>

div_t div(int x, int y);

La función div() calcula el cociente entero y el resto de x por y. La función devuelve una

estructura div_t definida en stdlib.h como

typedef struct { int quot; // cociente int rem; // resto } div_t;

div_t resultado; resultado = div(35, 8); // resultado.cociente = 4, resultado.resto = 3

§ exp #include <amth.h>

double exp(double x);

Calcula el exponencial de x:ex; donde e es la base del logaritmo natural (e = 2.7182818).

x = 100.00; y = exp(x); printf(“El exponencial de x = %f.\n”,y);

Funciones relacionadas: log, pow.

§ fabs, fabsl #include <math.h>

double fabs(double x);long double fabs(long double x);

Calcula el valor absoluto de un número en coma flotante x.

y = fabs(-7.25); // y vale 7.25

60

§ floor #include <math.h>

double floor(double x);

Redondea por defecto el valor de x.

x = floor(6.25); // x vale 6

Funciones relacionadas: ceil.

§ fmod #include <math.h>

double fmod(double x, double y);

Calcula el resto de la división real x por y.

resto = (fmod(5.0, 2.0); // resto igual a 1.0

Funciones relacionadas: floor.

§ _fpreset #include <float.h>

void _fpreset(void);

Reinicializa el paquete matemático de coma flotante. Debe utilizarse después de las llamadas a

las funciones system(), exec(), span() sobre máquinas con coprocesadores

matemáticos.

_fpreset(); // inicializa paquete de coma flotante *t

Funciones relacionadas: _control87, signal.

§ frexp(), frexpl() #include <math.h>

double frexp(double x, int *exp);

long double frexpl(long double x, int *exp);

La función frexp descompone el valor x en una mantisa (m) y en un exponente n, tal que el

valor absoluto de m es mayor o igual a 0.5 y menor que 1.0 y x + m*2n. La mantisa se obtiene

por la función, y el exponentes se almacena en la variable apuntada por exp.frexpl

descompone un valor long double.

double x, y; int n; x = 17.5; y = frexp(x, &n); printf(“frexp(%f, &n) = %f, n = %d\n”,x,y,n);

Funciones relacionadas: exp, ldexp, modf.

§ hypot #include <math.h>

61

double hypot(double x, double y);

Calcula la hipotenusa de un triángulo rectángulo cuyos lados son x e y. Una llamada a hypot

equivale a lo siguiente:

sqrt(x * x, y * y);

double x = 3.0; y = 4.0; printf(“%lf”, hypot(x, y));

§ labs #include <math.h>

long int labs(long int n);

Calcula el valor absoluto de un entero largo (n).

long lx = _51654L, ly; ly = labs(lx);

Funciones relacionadas: abs, cabs, fabs.

§ ldesp, ldespl #include <math.h>

double ldesp(double x, int exp);long double ldexpl(long double x, int exp);

Calcula y devuelve el valor real de x*eexp

.

double x = 4.0,y; int p = 5; y = ldexp(x, p);

Funciones relacionadas: frexp, modf.

§ ldiv #inxlude <stdlib.h>

ldiv_t ldiv(long int x, long int y);

Calcula el cociente y el resto de la división x/y. La función ldiv devuelve una estructura de

tipo ldiv_t que comprende el cociente y el resto.

typedef struct

{ long quot; long rem; } ldiv_t;

long x = 5258625, y = 341654; ldiv_t resultado; resultado = ldiv(x, y); printf(“el cociente y el resto es %ld, %ld,\n”, resultado.quot,

62

resultado.rem);

Funciones relacionadas: div.

§ log, log10 #include <math.h> #include <complex.h>

double log(double x);double log10(double x);

Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x. Si x es negativo, ambas

funciones devuelven un error de dominio DOMAIN en stderr, la variable global errno toma el

valor EDOM y devuelve el valor HUGE_VAL. Si x es 0, la función imprime un mensaje de error

SING en stderr, devuelve el valor HUGE_VAL y fija errno a ERANGE.

hdouble x, y; x = 10; y = log(x); y = log10(x);

Funciones relacionadas: exp, matherr pow.

§ _lrotl #include <stdlib.h>

unsigned long _lrotl(unsigned long x, int c);

Se utiliza _lrotl para rotar a la izquierda los bits de una variable entera larga sin signo x. La

rotación de un bit a la izquierda, una posición, significa que el bit más a la izquierda sale fuera y

se inserta en su posición el siguiente bit de mayor peso, y los restantes bits se desplazan una

posición a la izquierda.

unsigned long x = 0x0fac45491; printf(“x desplazado 4 veces es”, _lrotl (x, 4);

Funciones relacionadas: _lrotr, _rotl, _rotv.

§ _lrotr #include <stdlib.h>

unsigned long _lrotr(unsigned long x, int c);

Rota a la derecha los bits de x. Rotación a derecha de un bit significa salir fuera el bit de menor

peso y los restantes se desplazan una posición a la derecha.

val_r = _lrotr(x, 4);

Funciones relacionadas: _lrotl, _rotl, _rotr.

§ matherr #include <math.h> _matherrl

int matherr(struct exception *e);int _matherrl(struct _exception1 *e)

63

Esta función manipula errores matemáticos. Las funciones matemáticas llaman a la rutina

adecuada matherr cuando se detecta un error. Se puede desarrollar su propia versión de

matherr para personalizar su tratamiento de errores. Para profundizar en esta función,

consultar su referencia en Library Reference de Borland C++ (págs. 352-353).

Funciones relacionadas: Las funciones matemáticas.

§ max #include <conio.h>

(tipo) max(a, b);

Devuelve el mayor de dos valores. Ambos argumentos y la declaración de la función deben ser

del mismo tipo.

double dbl1, dbl2, dblmax; dblmax = max(dbl1, dbl2);

Funciones relacionadas: min.

§ min #include <stdlib.h>

(tipo) min(a, b);

Devuelve el menor de dos valores. Ambos argumentos y la declaración de la función deben ser

del mismo tipo.

int i1, i2, minent; minent = min(i1, i2);

Funciones relacionadas: max.

§ modf, modfl #include <math.h>

double modf(double x, double *partent);long double modfl(long double x, long double *partent);

La función modf divide un número de coma flotante en dos partes, entera y decimal. La parte

entera de x se almacena en la posición a cuya dirección apunta partent, y la parte decimal es

devuelta por la función.

pardecimal = modf(36.95, &parte_entera(; // parte entera 36, parte decimal .95

Funciones relacionadas: frexp, ldexp.

§ poly #include <math.h>

double poly(double x, int n, double c[]);

Se utiliza poly para evaluar un polinomio en x, de grado n y cuyos coeficientes son los

correspondientes al array c. La expresión utilizada para evaluar el polinomio es:

64

c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]

// polinomio: 3x**2 + 2x + 1// double c[] = {-10.0,2,c);

Funciones relacionadas: pow.

§ rand #include <stdlib.h>

int ran(void);

Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; esta constante simbólica está

definida en <stdlib.h> y su valor es 215-1. Para inicializar el generador de números

pseudoaleatorios se debe utilizar randomize. Para obtener un número en el rango de 0 a (n-1)

hay que utilizar random.

// visualizar 10 números aleatorios // for(i = 0; 1 < 10; i++) printf(“%6d\”, rand());

Funciones relacionadas: random, randomize, srand.

§ random #include <stdlib.h>

int random(int x);

Genera un número pseudoaleatorio en el rango de 0 a x-1.

// obtener un número aleatorio entre 0 y 20 numa1 = random(21);

Funciones relacionadas: rand, randomize.

§ randomize #include <stdlib.h> #include <time.h>

void randomize(void);

Inicializa (genera una semilla) el generador de números pseudoaleatorios con una semilla

aleatoria que es función de la hora actual. Esta función impide que se repitan las mismas

secuencias de números aleatorios en diferentes ejecuciones.

randomize();

Funciones relacionadas: rand, random, srand.

§ _rotl #include <stdlib.h>

unsigned _ rotl(unsigned x, int c);

Rota el valor de x, c bits a la izquierda.

65

modelo_nuevo = _rotl(0x1234,8); // resultado es 3412h

Funciones relacionadas: _lrotl, _rotr, _rotr.

§ _rotr #include <stdlib.h>

unsigned _rotr(unsigned x, int c);

Se utiliza _rotr para rotar a la derecha el valor de x, c bits.

_rotr(val, 4);

Funciones relacionadas: _lrotl, _lrotr, _rotl.

§ sin #include <math.h>

double sin(double x);complex sin(complex x);

La función sin() proporciona el seno de x (se supone en radianes).

double x, y; x = 0.52; printf(“x = %f radianes\n”, x); y = sin(x) printf(“el seno de x = %f\n”, y);

Funciones relacionadas: asin, cos, sinh.

§ sinh #include <math.h>

double sinh(double x);

Devuelve el seno hiperbólico de x (x, se supone en radianes).

y = sinh(x);

Funciones relacionadas: sin, cosh.

§ sqrt #include <math.h>

double sqrt(double x);

Calcula la raíz cuadrada de un número x no negativo.

printf(“%lf”,sqrt(25.0); // se visualiza 5

Funciones relacionadas: exp, log, pow.

§ srand #include <stdlib.h>

66

void srand(unsigned x);

srand inicializa el generador de números aleatorios con la semilla x. Si x es 1, el generador se

reinicializa; cualquier otro valor de x fija el generador a un punto inicial aleatorio.

srand(semilla);

Funciones relacionadas: rand, randomize.

§ _status87 #include <float.h>

unsigned int _status87(void);

Obtiene el contenido de la palabra de estado de coma flotante.

estado = _status87();

Funciones relacionadas: _clear87, _control87.

§ tan #include <math.h>

double tan(double x);

Calcula la tangente de x (x, se supone en radianes).

y = tan(x)

Funciones relacionadas: atan.

§ tanh #include <math.h>

double tanh(double x);

Calcula la tangente hiperbólica de x.

a = tanh(x);

Funciones relacionadas: cosh, tanh.

B.13. FUNCIONES DE MANIPULACIÓN DE BLOQUES DE MEMORIA (BUFFERS)

Las rutinas de manipulación de buffers son una forma general de las rutinas de manipulación de

cadenas que operan sobre éstas en C. Son útiles para trabajar con áreas de memoria sobre la

base de carácter a carácter. Un buffer es un array de caracteres similar a una cadena de

caracteres. Sin embargo, al contrario que las cadenas, los buffers no terminan normalmente con

un carácter nulo (´\0´). Por consiguiente, las rutinas de manipulación de buffers siempre toman

un argumento longitud o cuenta.

67

Las rutinas de manipulación requieren que el archivo de cabecera <mem.h> se incluya en su

programa.

§ memccpy #include <mem.h> #include <string.h>

void *memccpy(void *dest, const void *s, int c, size_t n);

Copia n bytes desde s a dest hasta que n bytes han sido copiados o c se copia a dest.

res = memccpy(buf _dest, bufen, ć´, 81);

Funciones relacionadas: memcpy, memmove, movedata, movmem.

§ memchr #include <mem.h> #include <string.h>

void *memchr(const void *buf, int c, size_t n);

Busca un carácter específico c en un buffer (buf) examinando los n primeros caracteres.

result = memchr(direc, Í´, 40);

Funciones relacionadas: memcmp, memicmp.

§ memcmp #include <mem.h>

int memcmp(const void *b1, const void *b2, size_t n);

Compara n bytes de un buffer (b1) con los de otro buffer (b2). Devuelve un valor:

< 0 si b1 < b2= 0 si b1 = b2 > 0 si b1 > b2

resultado = memcmp(buf1, buf2, sizeof(buf1));

Funciones relacionadas: memicmp.

§ memcpy #include

void *memcpy(void *dest, const void *fuente, size_t n);

Copia n bytes de fuente en dest. Devuelve un puntero a dest.

memcpy(dest, fuente, 80):

Funciones relacionadas: memccpy, memmove, movedata.

§ memicmp #include <mem.h> #include <string.h>

68

int memi (const void *b1, const void *b2, size_t n);

Compara un número de bytes de un buffer (b1) con otro (b2) sin hacer caso del tamaño de las

letras en los dos buffers.

if(memicmp(buf1, buf2, 15) == 0) puts(“Los buffers son iguales en los 15 primeros bytes \n”);

Funciones relacionadas: memcmp.

§ memmove #include <string.h> #include <mem.h>

void *memmove(void *dest, const void *f, size_t n);

Mueve n bytes de un buffer (f) a otro (dest).

Funciones relacionadas: memccpy, memcpy, movedata.

§ memset #include <string.h>

void *memset(void *s, int c, size_t n);

Fija los n primeros bytes del array s al carácter c.

resultado = memset(buffer,´1´, 50);

Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.

§ movedata #include <mem.h> #include <string.h>

void movedata (unsigned ss, unsigned so, unsigned ds, unsigned do, size:t n);

Mueve n bytes desde ss a ds, donde ss es el segmento fuente, so es el desplazamiento fuente,

ds es el segmento destino, do es el desplazamiento destino y n es el número de bytes que hay

que mover.

movedata(seg1, off, seg2, dest_off, 4096);

Funciones relacionadas: memcpy, memmove, movmem, segread.

§ movmem #include <mem.h>

void movmem(void *fuente, void *destino, unsigned n);

Copia n bytes de fuente a destino.

movmem(&fuente[6], fuente, sizeof(fuente));

Funciones relacionadas: memmove.

69

§ setmem #include <mem.h>

void setmem(void *dest, unsigned long, char c);

Fija un bloque de long bytes en el buffer dest al carácter c. setmem es útil para inicializar

buffers.

setmem(buffer, 60, ´t´);

Funciones relacionadas: memset.

§ swab #include <stdlib.h>

void swab(char *fuente, char *destino, int n);

Copia un número par de bytes de una posición a otra, intercambiando al mismo tiempo

cada par de bytes adyacentes.

swab(“mnpq”, resultado, 4); // resultado es “nmpq”

Funciones relacionadas: Sólo está disponible en sistemas UNIX.

A.14. FUNCIONES DE PRESENTACIÓN DE TEXTO

Las funciones de presentación de texto permiten definir coordenadas de una ventana de texto en

la pantalla y manipular texto. Con estas funciones se puede posicionar texto en cualquier parte

de la pantalla, seleccionar atributos de texto (tales como subrayado, vídeo inverso, parpadeo,

colores de fondo y primer plano), así como actuar sobre ventanas de texto. Estas funciones se

encuentran esencialmente en el archivo de cabecera conio.h.

§ clreol #include <conio.h>

void clreol(void);

Borra la línea actual desde la posición del cursor al final de la línea.

clreol()

Funciones relacionadas: clrscr, delline, textbackground, window.

§ clrscr #include <conio.h>

void (clrscr(void);

Borra la ventana actual y pone el cursor en la esquina superior izquierda (1,1).

clrscr();

Funciones relacionadas: clreol, textbackground, window.

70

§ delline #include <conio.h>

void delline(void);

Borra la línea completa que contiene el cursor y desplaza hacia arriba las líneas que

haya debajo.

delline();

Funciones relacionadas: clreol, clrscr.

§ gettext #include <conio.h>

int gettext(int izda, int arriba, int derecha, int abajo, void *textbuf);

Copia el contenido de un área rectangular de la pantalla al buffer cuya dirección se da en el

argumento textbuf. Todas las coordenadas son absolutas.

if(!gettext(1,1,30,20, pan_grabada)) puts(“color”);

Funciones relacionadas: movetext, puttext.

§ gettextinfo #include <conio.h>

void gettextinfo(struct text_info *r);

Devuelve información relativa a las coordenadas de la ventana actual, posición del cursor dentro

de la ventana, atributo del texto, las dimensiones de la pantalla y el modo de texto actual. La

información se devuelve en una estructura text_info.

struct text_info { unsigned char winleft; // coordenadas x, y esquina superior // izquierda unsigned char wintop; // ventana actual unsigned char winright; // coordenadas x, y esquina inferior // derecha unsigned char winbottom; // ventana actual unsigned char attribute; // atributo texto actual unsigned char normattr; // atributo texto normal unsigned char currmode; // modo texto actual unsigned char screenheight; // altura de la pantalla unsigned char screenwidth; // anchura pantalla unsigned char curx; // coordenada x cursor unsigned char cury; // coordenada y cursor };

§ gotoxy #include <conio.h>

void gotoxy(int x, int y);

71

Mueve el cursor a una posición especificada (columna x, fila y) dentro de la ventana de texto

actual.

gotoxy(15, 4);

Funciones relacionadas: wherex, wherey, window.

§ highvideo #include <conio.h>

void highvideo(void);

Activa caracteres de alta intensidad.

highvideo();

Funciones relacionadas: lowvideo, normvideo, textcolor.

§ insline #include <conio.h>

void insline(void);

Inserta una línea en blanco en la ventana de texto actual en la posición del cursor, desplazando

el resto de las líneas situadas debajo.

insline();

Funciones relacionadas: clreol, delline, window.

§ lowvideo #include <conio.h>

void lowvideo(void);

Activa los caracteres a baja intensidad.

lowvideo();

Funciones relacionadas: highvideo, normvideo, textcolor.

§ movetext #include <conio.h>

iont movetext(int izda, int arriba, int dcha, int abajo, int nuevoizda, int nuevoarriba);

Copia el contenido de una zona rectangular de la pantalla (en modo texto) a otro rectángulo en

la pantalla de las mismas dimensiones.

if (!movetext(1, 1, 30, 20, 40, 40)) puts(“victoria”);

Funciones relacionadas: gettext, puttext.

§ normvideo #include <conio.h>

72

void normvideo(void);

Reinicializa los atributos de texto al valor que tenían antes de que arranque el programa.

normvideo();

Funciones relacionadas: highvideo, lowvideo, textattr, textcolor.

§ puttext #include <conio.h>

int puttext(int izda, int arriba, int dcha, int abajo, void *textbuf);

Copia el contenido de un buffer en una zona rectangular de la pantalla en modo texto.

puttext(3, 1, 32, 22, buffertexto);

Funciones relacionadas: gettext, movetext.

§ _setcursortype #include <conio.h>

void setcursortype(int estilo_cursor);

Cambia la forma del cursor en modo texto. El argumento tiene que ser una de las constantes.

_NOCURSOR Desactiva el cursor.

_SOLIDCURSOR Un carácter bloque sólido es el cursor.

_NORMALCURSOR Un subrayado parpadeante es el cursor.

setcursortype(_SOLIDCURSOR);

Funciones relacionadas: cprintf, cputs.

§ textattr #include <conio.h>

void textattr(int atrib);

Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia del texto en la pantalla.

textattr(YELLOW + (RED << 4)); textattr(10110100);

Funciones relacionadas: gettextinfo, highvideo, lowvideo, normvideo,textbackground, textcolor.

§ textbackground #include <conio.h>

void textbackground(int colorfondo);

establece el color de fondo para texto vidualizado.

textbackground(2);

73

§ textcolor #include <conio.h>

void textcolor(int colorprimerplano);

Establece el color del primer plano del texto visualizado por cprintf y cputs. El argumento

puede tomar un valor entre 0 BLACK (negro) y 15 WHITE (blanco).

textcolor(15);t

Funciones relacionadas: textattr, textbackground.

§ texmode #include <conio.h>

void textmode(int nuevomodo);

Conmuta al modo texto especificado por el argumento nuevomodo.

-1 LASTMODE Ultimo modo de texto.

0 BW40 Monocromo 40 columnas.

1 C40 Color 40 columnas.

2 BW80 Monocromo 80 columnas.

3 C80 Color 80 columnas.7 MONO Monocromo 80 columnas.

64 C4350 EGA 43 filas o VGA 50 filas.

textmode(C40);

Funciones relacionadas: gettextinfo, restorecrtmode.

§ wherex #include <conio.h> wherey

int wherex(void); int wherey(void);

Determina la coordenada x (wherex) y la coordenada y (wherey) de la posición del cursor en

la ventana actual.

xpos = where(x); ypos = where(y);

§ window #include <conio.h>

void window(int izda, int arriba, int dcha, int abajo);

Define una región rectangular de la pantalla como la ventana de texto actual esquina superior

izquierda (izda, arriba) y esquina inferior derecha (dcha, abajo).

window(15, 5, 54, 14); // ventana de 40 x 10 con origen en (15, 5)

Funciones relacionadas: gettextinfo, textmode.

Documents

Ap.ndice W5. C biblioteca de funciones...En su lugar, las cadenas se tratan como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación el final de una cadena en