BIBLIOTECA DE FUNCIONES (ANSI C)

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.

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.

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

i 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 utilizarfarcalloc

.

Devuelve un puntero al bloque recién asignado. Si no existe bastante espacio para el nuevo bloque o bien n

o

s es 0

,

callocdevuelve nulo.

long *buffer

buffer=(long *) calloc(40, sizeof(long)); Funciones relacionadas free, malloc.

i farcalloc #include <alloc.h>

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

Esta función asigna n piezas de tamaño sy las pone a 0. Un puntero al principio de la memoria asignada se devuelve sifarcalloc()tiene éxito; en caso contrario se devuelveNULL

.

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

i 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 porfarmalloc

.

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.

i 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 memoriab

,

al cual se ha asignado una longitud de nbytes

.

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

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

i 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

i 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

.

Funciones relacionadas: calloc, free, realloc.

i realloc #include <alloc.h>

#include <stdlib.h> void *realloc(void *b, size_t n);

Ajusta el tamaño de un bloque de memoriabasignado por malloc

o

calloc a un tamaño de nbytes. Devuelve un punterovoidal bloque de memoria reasignado

.

Nuevo_buffer = realloc(viejo_buffer, long+100); Funciones relacionadas: calloc, free, malloc.

i sbrk #include <alloc.h>

void *sbr(int n);

Se utilizasbrk para indicar el valor breakde un proceso

.

El valorbreak 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

i setblock #include <alloc.h>

int setblock(unsigned seg, unsigned n);

Ajusta el tamaño de un bloque de memoria asignado anteriormente porallocmen

.

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

.

i 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ónbsearchrealiza una búsqueda binaria en un array ordenadob

,

denelementos, cada uno de a bytes de tamaño. El argumento k apunta al valor que se está buscando

.

bearch devuelve un puntero (la dirección) a la primera aparición del valor k en el array. Si no se encuentra el valor

,

bsearchdevuelve

o.

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

,

cada uno un puntero a un elemento del array. La función compararcompara 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 a bsearch.

Funciones relacionadas:lfind, lsearch, qsort.

i 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ónlfind()realiza una búsqueda lineal de valor dek(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.

i 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ónlsearchrealiza una búsqueda lineal de la clavek

.

El arrayacontiene 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 dek

.

La diferencia entrelsearch() y lfind()es quelsearch()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

.

i qsort #include <stdlib.h>

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

La función qsortordena 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 esn y el tamaño (en bytes) de cada elemento esw

.

La funcióncompararse 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

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. i 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 decad1+strlen(cad2)

stpcpy(orden_dos, “DIR”); stpcpy(caad1, cad2);

Funciones relacionadas

: strcat, strcpy, strncat, strncpy, strdup.

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

i 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 cencad

.

Si c no se encuentra, devuelve un cero

(

NULL

).

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

char *ptr;

ptr = strchr(s, ´a´);

el valor almacenado enptres un puntero a la primera aparición de

´

a

´.

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

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

i strcoll #include <string.h> int strcoll(const char *cad1, const char cad2);

Comparacad1concad2

.

Devuelve un valor. < 0 si cad1 < cad2

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

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

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

i strcpy() #include <string.h>

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

strcpy()copiacad2

en

cad1

.

Si la longitud de la cadena resultante excede el tamaño asignado a cad1

,

puede producir fallos en el progr

ama.

char *a = “Pepe Luis”; char b[12];

strcpy(b, a); puts(b);

Funciones relacionadas: strcat, strcup, strncat, strncpy.

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

i 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 acad

.

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;

}

i strerror #include <string.h>

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

.

La funciónstrerror()obtiene el mensaje de error del sistema utilizando el valor en la variable globalerrno

,

como el índice una tabla de errores denominadassys_errlist,que está declarado en el archivo de cabecerastdlib.h

.

errno = 0;

ptr = strerror(errno);

Funciones relacionadas: perror, _strerror.

i _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.

i 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 cad1con respecto acad2

.

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.

i 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 porstrlen

.

longitud = strlen(nombre); char s[81] = “Cadena demo”;

printf(“La longitud de s es:%d\n” strlen(s)); Funciones relacionadas: _fstrlen

i 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

i strncat #include <string.h>

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

La función strncat() añade los primerosn caracteres decad2

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 den

.

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.

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

i strnset #include <string.h>

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

.

El caráctercse utiliza para rellenar la cadena con ese carácter;nes 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

i 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

i strrchr #include <string.h>

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

Encuentra la última aparición del caráctercencad

.

Devuelve un puntero a la última aparición deco un carácter nulo sicno está encad

.

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

Funciones relacionadas: strchr

i 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 inv

ersa.

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

strrev(demo);

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

}

Funciones relacionadas: strcpy, strncpy.

i strset #include <string,h>

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

Establece todos los caracteres de la cadenacad al valor dec

.

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.

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

i 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ónstrstrdevuelve un puntero a la primera aparición decad2como una subcadena decad1

.

Si la búsqueda falla, se devuelveNULL

.

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

i 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 unNULLcuando se alcanza el final de la cadena.

char *s = “¿Prefiere a Verdi, o a Pucini?”; char *t = “.,!* ”;

puts(strtok(s, t)); puts(strtok(NULL, “!”));

Funciones relacionadas: strpbrk, strcspn.

i strxfrm #include <string.h>

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

Conviertecad2 encad1 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 cad1en los tres primeros caracteres decad2

.

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 cabeceractype.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 archivoctype.h que sirven para convertir caracteres en mayúsculas en minúsculas, y viceversa; y valores enteros en códigos ASCII.

i isalnum #include <ctype-h>

int isalnum(int c);

La funciónisalnum()devuelve un cero sices 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.

int isalpha(int c);

La funciónisalpha()verifica si un carácter es alfabético. Devuelve un valor distinto de cero sices un carácter alfabético, o 0 sicno es alfabético

.

int c = getah()

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

Funciones relacionadas: iascii.

i 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,

i 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.} ´a´..´z´´ isprint _{Carácter imprimible} 20h..7Eh

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

isspace _{Carácter blanco.} 9h..Dh 0 20h (blanco) isupper _{Carácter mayúscula.} ´A´..´Z´

isxdigit _{Dígito hexadecimal.} ´0´..´9´ ´A´..´F´ ´a´.. f´

Cada macro (función) devuelve un valor distinto de cero sicsatisface 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) Funciones relacionadas: iascii.

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

Funciones relacionadas: iascii. i _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. i _toupper

touper #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_touppersó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().

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 cabeceratime.h

.

i 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 estruct

ura

tmse define entime.hasí:

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.

i 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

i ctime #include <time.h>

char *ctime(const time_t *hora);

Convierte la fecha y hora almacenada como valor de tipotime_ten una cadena de caracteres (mes día hora año\0).

time_t hora;

hora = time(NULL);

printf(“Hora actual=%s\n”, ctime(&hora)); Funciones relacionadas: asctime, strtime, time.

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

i dostounix #include <dos.h>

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

Convierte la fecha y hora DOS (devuelta porgetdate

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.

i ftime #include <sys/timeb.h>

void ftime(struct timeb *ptrhora);

Obtiene la hora actual y la almacena en la estructuratimebapuntada porptrhora

.

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 */ };

Funciones relacionadas: time tzset.

i getdate #include <dos.h>

void gatdate(struct date *f);

Obtiene la fecha del sistema. Los componentes se almacenan en la estructuradatedefinida 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.

i 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 timedefinida endos.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.

i 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éasestruct tnenasctime

.

ahora = gmtime(&hoy);

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

i localtime #include <time.h>

Convierte una fecha y hora en varios campos de una estructura de tipo tm

.

Véasestruct tm enasctime

.

tiempoactual = localtime(&ahora);

Funciones relacionadas:asctime, gmtime, time

.

i mktime #include <time.h>

time_t mktime(struct tm *h);

Convierte la hora local a un valor de calendario. Véasestruct tmenasctime

.

Funciones relacionadas: asctime, gmtime, localtime, time.

i 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 estructuradate

.

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.

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

i 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 argumentot

.

time_t horasis;

horasis = time(NULL); stime(&horasis);

printf(“segundos desde 1/1/70 %ld”, horasis); Funciones relacionadas: dostounix.

i strftime #include <time.h>

size_t strftime(char *cad, size_t maxlon,

const char *formato, const struct tm *t);

Convierte un puntero en una estructuratmen una cadenacad(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.

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

i tzset #include <time.h>

void tzset(void);

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

lobales

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.

i 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

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 cabeceradir.h

.

i chdir #include <dir.h>

int chdir(const char *camino);

Cambia el directorio de trabajo actual al directorio especificado en el argumentocamino

.

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.

i 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 estructuraffblk

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 variableattrib 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 siste

ma.

FA_LABEL

Etiqueta de volumen.

FA_DIREC

Directorio.

FA_ARCH Bit de archivo activado

.

struct ffblk ffblk; int t;

Funciones relacionadas: findnext.

i 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ónfindfirst()

.

findnext(&filefinfo);

Funciones relacionadas: findfirst.

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

i 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 archiv

o (

ext

).

h = fnsplit(camino, unidad, dir, nomarch, ext); Funciones relacionadas: fnmerge.

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

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 argumentonumcar indica agetcwdel 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.

i 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

i mkdir #include <dir.h>

int mkdir(const char *camino);

Crea un directorio con un nombre de camino especificado. Funciona igual que la ordenMKDIR

o

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

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

i 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 aRMDIR

o

RDde MS-DOS

.

rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS Funciones relacionadas: chdir, mkdir.

i 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 entorn

o

PATH

.

Si el archivo se encuentra, se devuelve un puntero al nombre del camino del archivo; en caso contrario, se devuelveNULL

.

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.

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

...

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

.

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

i assert #include <assert.h>

void assert(int expresion);

Imprime un mensaje de error e interrumpe el programa siexpresiónes falsa (0). assert(string != NULL;

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

Funciones relacionadas: abort, raise, signal.

i atexit #include <stdlib.h>

int atexit(void(*func)(void)); Procesa la función especificada al salir. atexit(segundo);

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

i 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ónexitregistrada

.

estadorepresenta el estado de salida del programa; 0, salida normal; distinto de cero, indica un error

.

exit(0);

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

i _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.

i getenv #include <stdlib.n>

Obtiene la definición de una variable de la tabla de entorno del proceso. Utiliza la variable globalenvironpara localizar la lista de las variables de entorno y, a continuación., busca una entrada en la lista correspondiente anomvar

.

varlib = getenv(“LIB”); Funciones relacionadas: putenv.

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

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

i longjmp #include <setjmo.h>

void longjmp(jmp_buf env, int valor);

Restaura el estado de la pila y la ejecución local anteriormente grabada enenvporsetjmp

.

Longjmp(plaza, 3);

Funciones relacionadas: setjmp.

i perror #include <stdio.h>

void perror(const char *cadena);

Imprime un mensaje de error del sistema en el flujostderr

.

El argumentocadena

se

imprime primero, seguido por dos puntos, a continuación el mensaje de error correspondiente al valor actual de la variable globalerrnoy, 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.

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

i 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úmeroseñal

.

Existen diferentes constantes, por ejemplo

,

SIGABRT(terminación anormal). printf(“prueba de raise\n”);

raise(SIGABRT);

Funciones relacionadas:abort, signal.

i 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 alongjmp

,

realizando el efecto de un goto no local.

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

i 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. i 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,

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

.

i 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 nul

o (

´\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. i 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:

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

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

i 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. Sivalortiene más de ndígitos, los dígitos inferiores se truncan

.

deces un puntero a un entero en donde se devuelve la posición del punto decimal;signoes 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.

i 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 quenla cadena se rellena con ceros. fcvt se diferencia deecvt 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.

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

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

i ltoa #include <stdlib.h>

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

La funciónltoa()convierte el argumento entero largovaloren 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 acad

.

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

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

i strtod #include stdlib.h>

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

La funciónstrtod()convierte la cadenacad 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 flotantedouble

.

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

i 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

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 mac

ro

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.

i 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 baseb

es cero,

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

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

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 archivostdio.h

.

i clearerr #include <stdio.h>

void clearerr(FILE *f);

Reinicializa el indicador de error de un flujof

.

clearerr(fichen);

Funciones relacionadas: eof, feof, ferror, perror.

i 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 yEOFsi se produce un error

.

fcloseall();

Funciones relacionadas: close, fdopen, fopen.

i fdopen #include <stdio.h>

Abre un flujo utilizando unhandle

(

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 porhandle

.

p_datos = fdopen(handle, “rb”);

Funciones relacionadas: fclose, fopen, fropen, open.

i feof #include <stdio.h>

int feof(FILE *flujo);

Comprueba el final de archivo de un flujo

.

feof(fichen);

Funciones relacionadas: clearerr, fclose, rewind.

i ferror #include <stdio.h>

int ferror(FILE *f);

Verifica si se ha producido un error en un flujof

.

ferror(fichen);

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

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

i 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. i fgetchar #include <stdio.h>

Lee un carácter del archivostdin

,

normalmetne el teclado

.

c = fgetchar();

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

i fgetpos #include <stdio.h>

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

Obtiene y graba la posición actual del arc

hivo.

fos_tes un tipo definido enstdio.h

.

fgetpos(fp, &pos_archivo);

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

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

i fopen #include <stdio.h>

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

Abre un archivof

.

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.

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

i flushall #include stdio.h>

int flushall(void);

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

numvaciados = flushall();

Funciones relacionadas: fclose, fflush.

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

i fputc #include <stdio.h>

int fputc(int c, FILE *f);

Escribe un caráctercen el flujo abierto para salida con buffer

.

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

Funciones relacionadas:fgetc, fgetchar, fputchar, getc, getchar, putc. i fputchar #include <stdio.h>

int fputchar(int c); Escribe el carácterc

en

stdout

.

Fputchar(´q´);

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

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

Escribe una letracaden un flujof

.

Devuelve el último carácter impreso, si hay error devuelve EOF

.

fputs(“esto es una prueba”, f1); Funciones relacionadas fgets, gets, puts.

i fread #include <stdio.h>

size_t fread(void *p, size_t t, size_t n, FILE *f); Lee n registros detbytes en la memoria apuntada porpdesde el flujof

.

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

Funciones relacionadas: fwrite, read.

i freopen #include <stdio.h>

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

Cierra el archivo asociado con flujo y reasignaflujoal archivo especificado porf. Los modos (m

)

utilizados son los mismos defopen

.

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

Fu

nciones relacionadas: fclose, fopen.

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

i fseek #include <stdio.h>

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

Mueve el puntero del archivo asociado con fa una nueva posición que está desplazada desp bytes deorg

.

Origen

Significado

SEEK_SET Principio de archivo.

SEEK_CUR Posición actual puntero archivo. SEK_END Final de archivo.