Introducción al lenguaje C. Biblioteca de funciones Turbo C

Elementos de un programa C. Tipos básicos de datos. E/S básica. Sentencias de control. Funciones. Asignación dinámica de memoria. Ficheros. Ficheros indexados: la interfase Btrieve. Compilación y enlazado. Biblioteca de funciones de Turbo C

  • Enviado por: Juan
  • Idioma: castellano
  • País: España España
  • 36 páginas
publicidad
publicidad

13

La biblioteca

de funciones de Turbo C

Introducción

A continuación se describen algunas de las funciones de la biblioteca de Turbo C, agrupadas por categorías. Algunas ya han sido explicadas en capítulos precedentes, por lo que no se volverán a tratar aquí. No se recogen en este capítulo todas las funciones, sino sólo algunas más comúnmente usadas. Un conocimiento pormenorizado de todas ellas se encuentra en el Library Reference de Turbo C.

Funciones de E/S

Ya se han estudiado las siguientes funciones en el Capítulo 4:

fprintf

getch

getche

gets

printf

putchar

puts

scanf

y en el Capítulo 11:

fclose

feof

ferror

fgetc

fgets

fopen

fprintf

fputc

fputs

fread

fscanf

fseek

fwrite

getc

getw

perror

putc

putw

rewind

A continuación se explican otras funciones de E/S:

cgets

Prototipo: char *cgets (char *cad);

Include: conio.h

Propósito: Esta función lee una cadena de caracteres del teclado, almacenando dicha cadena (y su longitud) en la posición apuntada por cad.

cgets lee caracteres hasta que se teclea o hasta un número máximo permitido de caracteres. El se reemplaza por un terminador nulo '\0'.

Antes de llamar a cgets hay que guardar en cad[0] la longitud máxima permitida para la cadena cad. Después de acabar, cgets almacena en cad[1] el número de caracteres tecleados. La cadena tecleada se almacena a partir de cad[2]. Todo esto implica que para cad deben reservarse 2 bytes más que el número máximo de caracteres.

Devuelve: Un puntero a cad[2].

Portabilidad: Sólo IBM-PCs y compatibles.

remove

Prototipo: int remove (const char *fichero);

Include: stdio.h

Propósito: Borra el fichero especificado mediante fichero. El fichero debe estar cerrado.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y la variable global errno asume alguno de los valores siguientes:

ENOENT No existe el fichero

EACCES Permiso denegado

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

rename

Prototipo: int rename (const char *viejofich, const char *nuevofich);

Include: stdio.h

Propósito: Cambia el nombre del fichero viejofich a nuevofich. Ambos deben estar almacenados en la misma unidad. Si el directorio de ambos no coincide, rename mueve el fichero de un directorio a otro. No se permiten comodines.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y la variable global errno asume uno de los valores siguientes:

ENOENT No existe el fichero

EACCES Permiso denegado

ENOTSAM Dispositivo no coincide

Portabilidad: Es compatible con ANSI.C

sprintf

Prototipo: int sprintf (char *cad, const char *format [, argumento, ...]);

Include: stdio.h

Propósito: Esta función es idéntica a printf pero en lugar de realizar la salida a pantalla, la realiza sobre la cadena cad.

Devuelve: El número de caracteres almacenados en cad (sin contar el terminador nulo). Si ocurre un error, devuelve EOF.

Portabilidad: Esta disponible para UNIX y está definida en ANSI C. Es compatible con K&R.

sscanf

Prototipo: int sscanf (const char *cad, const char *format [,direcc, ...]);

Include: stdio.h

Propósito: Funciona igual que scanf pero no lee los datos del teclado sino de la cadena cad.

Devuelve: El número de campos leídos, convertidos y almacenados en sus variables. Si se intenta leer un fin de cadena, devuelve EOF.

Portabilidad: Esta disponible para UNIX y está definida en ANSI C. Es compatible con K&R.

tmpfile

Prototipo: FILE *tmpfile (void);

Include: stdio.h

Propósito: Abre un fichero temporal en modo w+b. El fichero se borra cuando se cierra o acaba el programa.

Devuelve: Si no hay error devuelve un puntero al canal asociado al fichero. En caso contrario devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

tmpnam

Prototipo: char *tmpnam (char *nombre);

Include: stdio.h

Propósito: Genera un nombre no existente para un fichero temporal y lo almacena en nombre. Es responsabilidad del programador abrir, cerrar o borrar el fichero.

Devuelve: Si nombre es la cadena nula, devuelve un puntero a una variable estática interna. En caso contrario devuelve un puntero a nombre.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

Funciones de cadenas de caracteres

Funciones estudiadas en el Capítulo 7:

strcat

strchr

strcmp

strcpy

strlen

strlwr

strrev

strset

strupr

Otras funciones se explican a continuación.

strerror

Prototipo: char *strerror (int nerror);

Include: stdio.h, string.h

Propósito: Devuelve un puntero a una cadena que almacena un mensaje de error asociado a nerror.

Devuelve: Un puntero a una cadena con un mensaje de error. La cadena se almacena en un buffer estático que se sobreescribe en cada llamada a la función.

Portabilidad: Es compatible con ANSI C.

stricmp

Prototipo: int stricmp (const char *cad1, const char *cad2);

Include: string.h

Propósito: Es una función idéntica a strcmp salvo en que no diferencia mayúsculas y minúsculas.

Devuelve: < 0 si cad1 < cad2

= 0 si cad1 = cad2

> 0 si cad1 > cad2

Portabilidad: Sólo DOS.

strncat

Prototipo: char *strncat (char *dest, const char *orig, size_t max);

Include: string.h

Propósito: Copia un máximo de max caracteres de la cadena orig en la cadena dest y añade el terminador nulo.

Devuelve: Un puntero a dest.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

strncmp

Prototipo: int strncmp (const char *cad1, const char *cad2, size_t max);

Include: string.h

Propósito: Es idéntica a strcmp pero no compara cadenas completas, sino sólo los primeros max caracteres.

Devuelve: < 0 si cad1 < cad2

= 0 si cad1 = cad2

> 0 si cad1 > cad2

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

strncpy

Prototipo: char strncpy (const char *dest, const char *orig, size_t max);

Include: string.h

Propósito: Copia hasta max caracteres de orig en dest. La cadena dest podría no tener un terminador nulo si el tamaño de orig es max o mayor.

Devuelve: Un puntero a dest.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

strnset

Prototipo: char *strnset (char *cad, int carac, size_t n);

Include: string.h

Propósito: Pone el carácter carac en los primeros n bytes de cad. La operación finaliza cuando se han escrito n caracteres o se encuentra el terminador nulo.

Devuelve: Un puntero a cad.

Portabilidad: Sólo DOS.

strrchr

Prototipo: char *strrchr (const char *cad, int carac);

Include: string.h

Propósito: Busca en dirección inversa el carácter carac en la cadena cad, considerando el terminador nulo como parte de cad.

Devuelve: Si encuentra carac devuelve un puntero a esa dirección. En caso contrario devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

strstr

Prototipo: char *strstr (const char *cad, const char *subcad);

Include: string.h

Propósito: Busca la primera aparición de subcad en cad.

Devuelve: Si subcad está en cad devuelve un puntero al lugar de cad en que comienza subcad. En caso contrario devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

Funciones de memoria

memchr

Prototipo: void *memchr (const void *bloque, int carac, size_t n);

Include: string.h, mem.h

Propósito: Busca la primera aparición del carácter carac en los primeros n bytes del bloque de memoria apuntado por bloque.

Devuelve: Un puntero a la primera aparición de carac en bloque. Si no lo encuentra devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX System V y es compatible con ANSI C.

memcmp

Prototipo: int memcmp (const void *bloque1, const void *bloque2, size_t n);

Include: string.h, mem.h

Propósito: Compara dos bloques de memoria de n bytes de longitud.

Devuelve: < 0 si bloque1 < bloque2

= 0 si bloque1 = bloque2

> 0 si bloque1 > bloque2

Portabilidad: Está disponible para UNIX System V y es compatible con ANSI C.

memcpy

Prototipo: void *memcpy (void *dest, const void *orig, size_t n);

Include: string.h, mem.h

Propósito: Copia un bloque de n bytes desde orig hasta dest. Es misión del programador controlar que orig y dest no se superponen.

Devuelve: Un puntero a dest.

Portabilidad: Está disponible para UNIX System V y es compatible con ANSI C.

memicmp

Prototipo: int memicp (const void *bloque1, const void *bloque2, size_t n);

Include: string.h, mem.h

Propósito: Compara los primeros n bytes de bloque1 y bloque2, sin diferenciar mayúsculas y minúsculas.

Devuelve: < 0 si bloque1 < bloque2

= 0 si bloque1 = bloque2

> 0 si bloque1 > bloque2

Portabilidad: Está disponible para UNIX System V.

memmove

Prototipo: void *memmove (void *dest, const void *orig, size_t n);

Include: string.h, mem.h

Propósito: Copia un bloque de n bytes desde orig hasta dest. Incluso cuando los bloques se superponen, los bytes en las posiciones superpuestas se copian correctamente.

Devuelve: Un puntero a dest.

Portabilidad: Está disponible para UNIX System V y es compatible con ANSI C.

memset

Prototipo: void *memset (void *bloque, int carac, size_t n);

Include: string.h, mem.h

Propósito: Pone en los n primeros bytes de bloque el carácter carac.

Devuelve: Un puntero a bloque.

Portabilidad: Está disponible para UNIX System V y es compatible con ANSI C.

movedata

Prototipo: void movedata (unsigned seg1, unsigned off1, unsigned seg2, unsigned off2, size_t n);

Include: mem.h, string.h

Propósito: Copia n bytes desde la dirección seg1:off1 hasta la dirección seg2:off2.

Devuelve:

Portabilidad: Sólo DOS.

movmem

Prototipo: void movmem (void *orig, void *dest, unsigned n);

Include: mem.h

Propósito: Mueve un bloque de n bytes desde orig hasta dest. Incluso si orig y dest se superponen los bytes se mueven correctamente.

Devuelve:

Portabilidad: Sólo Turbo C++.

Funciones de caracteres

Funciones estudiadas en el Capítulo 7:

isalnum

isalpha

isdigit

islower

isupper

tolower

toupper

Otras funciones

isascii

Prototipo: int isascii (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un carácter perteneciente al conjunto de caracteres ASCII no extendido, de 0 a 127.

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX.

iscntrl

Prototipo: int iscntrl (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un carácter de control, es decir, de código ASCII de 0 a 31 ó 127.

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX y es compatible con ANSI C.

isgraph

Prototipo: int isgraph (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un carácter imprimible distinto del espacio (código ASCII de 33 a 126).

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX y es compatible con ANSI C.

isprint

Prototipo: int isprint (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un carácter imprimible incluyendo el espacio (código ASCII de 32 a 126).

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX y es compatible con ANSI C.

ispunct

Prototipo: int ispunct (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un carácter de puntuación, es decir, un carácter de control incluyendo el espacio.

Devuelve: 1 en caso afirmativo, 0 en caso contrario

Portabilidad: Está disponible para UNIX y es compatible con ANSI C.

isspace

Prototipo: int isspace (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un espacio, retorno de carro, tabulador vertical, tabulador horizontal, salto de página o salto de línea.

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX y es compatible con ANSI C. Es compatible con K&R.

isxdigit

Prototipo: int isxdigit (int carac);

Include: ctype.h

Propósito: Informa acerca de si carac es un dígito hexadecimal (0-9, a-f, A-F).

Devuelve: 1 en caso afirmativo, 0 en caso contrario.

Portabilidad: Está disponible para UNIX y es compatible con ANSI C.

Funciones matemáticas

Aparte de las funciones que se muestran en este apartado, Turbo C proporciona un grupo importante de funciones trigonométricas, logarítmicas, exponenciales, hiperbólicas y complejas.

exp

Prototipo: double exp (double x);

Include: math.h

Propósito: Calcula ex.

Devuelve: El valor calculado. Si este valor es demasiado grande para representarse como double devuelve HUGE_VAL.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

fabs

Prototipo: double fabs (double x);

Include: math.h

Propósito: Calcula el valor absoluto de x.

Devuelve: El valor absoluto de x.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

floor

Prototipo: double floor (double x);

Include: math.h

Propósito: Redondea x hacia abajo.

Devuelve: El mayor entero que no es mayor que x.

Portabilidad: Está disponible para UNIX y está definida en ANSI.C

modf

Prototipo: double modf (double x, double *entera);

Include: math.h

Propósito: Descompone x en parte entera (que se almacena en entera) y parte fraccionaria.

Devuelve: La parte fraccionaria.

Portabilidad: Sólo DOS.

pow

Prototipo: double pow (double x, double y);

Include: math.h

Propósito: Calcula xy.

Devuelve: Si tiene éxito, el valor calculado. Si hay desbordamiento devuelve HUGE_VAL y asigna a la variable global errno el valor ERANGE. Si x vale 0 e y es menor o igual a 0 se produce un error de dominio y asigna a errno el valor EDOM.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

sqrt

Prototipo: double sqrt (double x);

Include: math.h

Propósito: Calcula la raíz cuadrada positiva de x.

Devuelve: Si tiene éxito devuelve el valor calculado. Si x es negativo se produce un error de dominio y se asigna a la variable global errno el valor EDOM.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

Funciones de sistema

absread

Prototipo: int absread (int unidad, int nsec, int desde, void *buffer);

Include: dos.h

Propósito: Lee nsec sectores de la unidad especificada con unidad (A=0, B=1, ...) a partir del sector desde y los almacena en buffer. Utiliza para la lectura la interrupción DOS 0x25. El número de sectores a leer está limitado a 64 Kb.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y asigna a la variable global errno el valor devuelto por el sistema en el registro AX.

Portabilidad: Sólo DOS.

abswrite

Prototipo: int abswrite (int unidad, int nsec, int desde, void *buffer);

Include: dos.h

Propósito: Escribe en la unidad especificada con unidad (A=0, B=1, ...) nsec sectores a partir del sector desde. La información debe estar almacenada en buffer. Utiliza la interrupción DOS 0x26. El número de sectores a escribir está limitado a 64 Kb.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y asigna a la variable global errno el valor devuelto por el sistema en el registro AX.

Portabilidad: Sólo DOS.

biosequip

Prototipo: int biosequip (void);

Include: bios.h

Propósito: Usa la interrupción 0x11 para devolver un entero con información sobre el equipamiento del sistema.

Devuelve: Una palabra cuyos bits deben interpretarse según se explica a continuación:

14-15: Número de impresoras paralelo instaladas.

13: Impresora serie.

12: Adaptador de juegos.

9-11: Número de puertos COM.

8: Chip de acceso directo a memoria (DMA) instalado. Si vale 0 indica que sí.

6-7: Número de unidades de disquette, si el bit-0 es 1.

00 = 1 unidad.

01 = 2 unidades.

10 = 3 unidades.

11 = 4 unidades.

4-5: Modo de vídeo inicial:

00 = No usado.

01 = 40x25 BN con adaptador color.

10 = 80x25 BN con adaptador color.

11 = 80x25 BN con adaptador monocromo.

2-3: RAM en placa base:

00 = 16 Kb.

01 = 32 Kb.

10 = 48 Kb.

11 = 64 Kb.

1: Coprocesador matemático.

0: Arranque desde disquette.

Portabilidad: Sólo IBM-PC's y compatibles.

bioskey

Prototipo: int bioskey (int op);

Include: bios.h

Propósito: Realiza varias operaciones sobre el teclado usando la interrupción 0x16. La operación a realizar depende del valor de op.

Devuelve: El valor devuelto depende de op:

0: Espera a que se pulse una tecla y devuelve su valor en 2 bytes: el byte bajo contiene el cógigo ASCII. Si este es 0 (tecla especial), en el byte alto devuelve el código extendido.

1: Revisa si se pulsa una tecla. Devuelve 0 si no se ha pulsado ninguna, y diferente de 0 en caso contrario.

2: Devuelve un byte con el estado de alguna de las teclas, representando cada bit el estado de una tecla diferente:

0: MAYÚSCULAS DCHA pulsada.

1: MAYÚSCULAS IZQDA pulsada.

2: Tecla CONTROL pulsada.

3: Tecla ALT pulsada.

4: Tecla BLOQ DESPL activada.

5: Tecla BLOQ NUM activada.

6: Tecla BLOQ MAYÚS activada.

7: Tecla INSERT activada.

Portabilidad: Sólo IBM-PC's y compatibles.

biosmemory

Prototipo: int biosmemory (void);

Include: bios.h

Propósito: Obtiene la cantidad de RAM mediante la interrupción 0x12 del BIOS. No incluye memoria de vídeo, extendida ni expandida.

Devuelve: La cantidad de RAM en bloques de 1 Kb.

Portabilidad: Sólo IBM-PC's y compatibles.

biosprint

Prototipo: int biosprint (int op, int byte, int puerto);

Include: bios.h

Propósito: Realiza varias operaciones sobre el puerto paralelo de la impresora usando la interrupción 0x17 del BIOS. El valor de puerto es 0 para LPT1, 1 para LPT2, etc. Las operaciones realizadas dependen del valor de op:

0: Envía a la impresora el byte byte.

1: Inicializa el puerto.

2: Obtiene el estado de la impresora.

Devuelve: Un byte de estado de la impresora. Cada bit debe interpretarse como sigue:

0: Error de time-out.

1-2: Sin usar.

3: Error de E/S.

4: Impresora conctada.

5: No hay papel.

6: Reconocimiento (ACK).

7: No ocupada.

Portabilidad: Sólo IBM-PC's y compatibles.

biostime

Prototipo: long biostime (int op, long nuevot);

Include: bios.h

Propósito: Lee o asigna un valor al reloj del sistema. Este reloj se inicializa a medianoche y se incrementa a razón de 18.2 ticks por segundo. Si op vale 0 lee el reloj; si vale 1, asigna al sistema el valor nuevot.

Devuelve: Si op vale 0 devuelve el valor actual del reloj del sistema.

Portabilidad: Sólo IBM-PC's y compatibles.

clock

Prototipo: clock_t clock (void);

Include: time.h

Propósito: Determina el tiempo de proceso. Puede usarse para calcular el tiempo transcurrido entre dos sucesos. Para determinar el tiempo en segundos, el valor devuelto por clock debe dividirse por la macro CLK_TCK.

Devuelve: El tiempo de proceso desde el comienzo del programa. Si hay error, devuelve -1.

Portabilidad: Es compatible con ANSI C.

delay

Prototipo: void delay (unsigned ms);

Include: dos.h

Propósito: Detiene la ejecución del programa durante ms milisegundos.

Devuelve:

Portabilidad: Sólo IBM-PC's y compatibles.

FP_OFF

Prototipo: unsigned FP_OFF (void far *p);

Include: dos.h

Propósito: Es una macro que obtiene el valor de desplazamiento del puntero p.

Devuelve: El valor del desplazamiento.

Portabilidad: Sólo DOS.

FP_SEG

Prototipo: unsigned FP_SEG (void far *p);

Include: dos.h

Propósito: Es una macro que obtiene el valor de segmento del puntero p.

Devuelve: El valor de segmento.

Portabilidad: Sólo DOS.

getdate

Prototipo: void getdate (struct date *fecha);

Include: dos.h

Propósito: Obtiene la fecha del sistema mediante una estructura date apuntada por fecha. La estructura date esta definida como sigue:

struct date {

int da_year; //año

int da_day; //día

int da_mon; //mes

};

Devuelve:

Portabilidad: Sólo DOS.

gettime

Prototipo: void gettime (struct time *hora);

Include: dos.h

Propósito: Obtiene la hora del sistema mediante una estructura time apuntada por hora. La estructura time está definida como sigue:

struct time {

unsigned char ti_min; //minutos

unsigned char ti_hour; //horas

unsigned char ti_hund; //centésimas de seg.

unsigned char ti_sec; //segundos

};

Devuelve:

Portabilidad: Sólo DOS.

int86

Prototipo: int int86 (int nint, union REGS *regin, union REGS *regout);

Include: dos.h

Propósito: Ejecuta la interrupción especificada por nint. Antes de llamar a la función deben ponerse en la estructura apuntada por regin los valores adecuados en los registros del procesador. La estructura REGS está definida como sigue:

struct WORDREGS {

unsigned int ax, bx, cx, dx, si, di, cflag;

};

struct BYTEREGS {

unsigned char al, ah, bl, bh, cl, ch, dl, dh;

};

union REGS {

struct WORDREGS x;

struct BYTEREGS h;

};

Después de ejecutada la función, la estructura apuntada por regout contiene los valores de los registros del procesador devueltos.

Devuelve: El valor dejado en AX por la rutina de interrupción. Si el indicador de acarreo (representado por x.cflag) está activado indicando un error, la función asigna a la variable global _doserrno el código de error.

Portabilidad: Sólo para la familia de procesadores 8086.

int86x

Prototipo: int int86x (int nint, union REGS *regin, union REGS *regout, struct SREGS *regseg);

Include: dos.h

Propósito: Es idéntica a la anterior, pero utiliza la estructura SREGS que está definida como sigue:

struct SREGS {

unsigned int es;

unsigned int cs;

unsigned int ss;

unsigned int ds;

};

Esta función copia antes de ejecutar la interrupción, los valores de ds y es en los correspondientes registros. Esto permite a los programas usar punteros lejanos o el modelo grande de memoria para especificar qué segmento de memoria debe usarse en la interrupción.

Devuelve: El valor dejado en AX por la rutina de interrupción. Si el indicador de acarreo (representado por x.cflag) está activado indicando un error, la función asigna a la variable global _doserrno el código de error.

Portabilidad: Sólo para la familia de procesadores 8086.

intdos

Prototipo: int intdos (union REGS *regin, union REGS *regout);

Include: dos.h

Propósito: Es idéntica a int86 pero sólo para la interrupción 0x21.

Devuelve: El valor dejado en AX por la rutina de interrupción. Si hay error se activa el indicador de acarreo x.cflag, y se asigna a la variable global _doserrno el código de error. La estructura REGS se muestra en la página 222 (int86).

Portabilidad: Sólo para la familia de procesadores 8086.

intdosx

Prototipo: int intdosx (union REGS *regin, union REGS *regout, struct SREGS *regseg);

Include: dos.h

Propósito: Es idéntica a int86x pero sólo para la interrupción 0x21.

Devuelve: El valor dejado en AX por la interrupción. Si hay error se activa el indicador de acarreo x.cflag, y se asigna a la variable global _doserrno el código de error. Las estructuras REGS y SREGS se muestran en la página 222 (int86 e int86x).

Portabilidad: Sólo para la familia de procesadores 8086.

peek

Prototipo: int peek (unsigned segmento, unsigned despl);

Include: dos.h

Propósito: Lee la palabra situada en la dirección segmento:despl.

Devuelve: El valor leído.

Portabilidad: Sólo para la familia de procesadores 8086.

peekb

Prototipo: char peekb (unsigned segmento, unsigned despl);

Include: dos.h

Propósito: Lee el byte situado en la dirección segmento:despl.

Devuelve: El valor leído.

Portabilidad: Sólo para la familia de procesadores 8086.

poke

Prototipo: void poke (unsigned segmento, unsigned despl, int valor);

Include: dos.h

Propósito: Almacena el entero valor en la dirección segmento:despl.

Devuelve:

Portabilidad: Sólo para la familia de procesadores 8086.

pokeb

Prototipo: void pokeb (unsigned segmento, unsigned despl, char valor);

Include: dos.h

Propósito: Almacena el byte valor en la dirección segmento:despl.

Devuelve:

Portabilidad: Sólo para la familia de procesadores 8086.

segread

Prototipo: void segread (struct SREGS *regseg);

Include: dos.h

Propósito: Obtiene los valores de los registros de segmento. La estructura SREGS está definida en la página 221 (int86x).

Devuelve:

Portabilidad: Sólo para la familia de procesadores 8086.

setdate

Prototipo: void setdate (struct date *fecha);

Include: dos.h

Propósito: Establece la fecha del sistema. La estructura date está definida en la página 221 (getdate).

Devuelve:

Portabilidad: Sólo DOS.

settime

Prototipo: void settime (struct time *hora);

Include: dos.h

Propósito: Establece la hora del sistema. La estructura time está definida en la página 221 (gettime).

Devuelve:

Portabilidad: Sólo DOS.

sleep

Prototipo: void sleep (unsigned seg);

Include: dos.h

Propósito: Suspende la ejecución del programa durante seg segundos.

Devuelve:

Portabilidad: Esta disponible para UNIX.

Funciones de asignación dinámica de memoria

Ya se han estudiado en el Capítulo 9 las funciones:

free

malloc

Otras funciones se explican a continuación.

calloc

Prototipo: void *calloc (size_t n, size_t tam);

Include: stdlib.h, alloc.h

Propósito: Asigna un bloque de n elementos de tam bytes del motón, inicializándolo a 0.

Devuelve: Si tiene éxito, un puntero al bloque asignado. En caso contrario devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX y está definida en ANSI C. Es compatible con K&R.

coreleft

Prototipo: unsigned coreleft (void);

unsined long coreleft (void);

Include: alloc.h

Propósito: Obtiene una medida de la cantidad de memoria libre en el montón.

Devuelve: El número de bytes libres del montón.

Portabilidad: Sólo DOS.

realloc

Prototipo: void *realloc (void *p, size_t tam);

Include: stdlib.h, alloc.h

Propósito: Cambia el tamaño de memoria asignada apuntada por p al nuevo tamaño dado por tam.

Devuelve: Un puntero al bloque asignado. Este puede ser diferente del anterior. Si no tiene éxito, devuelve un puntero nulo.

Portabilidad: Está disponible para UNIX y está definido en ANSI C.

Funciones de directorio

chdir

Prototipo: int chdir (const char *nuevodir);

Include: dir.h

Propósito: Establece como directorio actual nuevodir.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y asigna a la variable global errno el valor ENOENT.

Portabilidad: Está disponible para UNIX.

findfirst

Prototipo: int findfirst (const char *path, struct ffblk *bloque, int atrib);

Include: dir.h, dos.h

Propósito: Busca el primer nombre de archivo que coincida con path. El nombre de archivo puede contener comodines * y ?. Si el archivo se encuentra, llena la información de la estructura ffblk apuntada por bloque. Esta estructura está definida como sigue:

struct ffblk {

char ff_reserved[21]; //Reservado por DOS

char ff_attrib; //Atributos de archivo

int ff_ftime; //Hora (Campo de bits)

int ff_date; //Fecha (Campo de bits)

long ff_fsize; //Tamaño

char ff_name[13]; //Nombre

};

En el parámetro atrib se selecciona el tipo de archivo que se buscará. Puede tener alguno de los siguientes valores:

FA_RDONLY Archivo de sólo-lectura

FA_HIDDEN Archivo oculto

FA_SYSTEM Archivo de sistema

FA_LABEL Etiqueta de volumen

FA_DIREC Directorio

FA_ARCH Archivo

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y asigna a la variable global errno alguno de los siguientes valores:

ENOENT Archivo no encontrado

ENMFILE No más ficheros

Portabilidad: Sólo DOS

findnext

Prototipo: int findnext (struct ffblk *bloque);

Include: dir.h

Propósito: Continúa la búsqueda iniciada por findfirst.

Devuelve: Los mismos valores que findfirst.

Portabilidad: Sólo DOS.

getcurdir

Prototipo: int getcurdir (int unidad, char *directorio);

Include: dir.h

Propósito: Pone en la cadena directorio el directorio actual de trabajo para el disco unidad (0: defecto, 1: A, 2: B, ...).La cadena directorio debe tener como máximo MAXDIR caracteres. La macro MAXDIR está definida en dir.h.

Devuelve: Si tiene éxito devuelve 0. En caso contrario, -1.

Portabilidad: Sólo DOS.

getcwd

Prototipo: char *getcwd (char *buffer, int longbuf);

Include: dir.h

Propósito: Copia el directorio actual de trabajo y lo sitúa en la cadena buffer. Si el nombre del directorio tiene más de longbuf caracteres, se produce un error. Si buffer es nulo, la función asigna memoria para buffer con una llamada a malloc. En ese caso, puede liberarse la memoria asignada mediante free.

Devuelve: Un puntero a buffer si tiene éxito. En caso contrario devuelve un puntero nulo. Si ocurre un error, asigna a la variable global errno uno de los valores siguientes:

ENODEV No existe el dispositivo

ENOMEM No hay suficiente memoria

ERANGE Resultado fuera de rango

Portabilidad: Sólo DOS

getdisk

Prototipo: int getdisk (void);

Include: dir.h

Propósito: Obtiene el número de la unidad actual.

Devuelve: 0 para A:, 1 para B:, etc.

Portabilidad: Sólo DOS.

mkdir

Prototipo: int mkdir (const char *directorio);

Include: dir.h

Propósito: Crea el directorio indicado en la cadena directorio.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1, y asigna a la variable global errno alguno de los valores siguientes:

EACCES Acceso denegado

ENOENT Encaminamiento no válido

Portabilidad:

mktemp

Prototipo: char *mktemp (char *nombre);

Include: dir.h

Propósito: Crea un nombre de archivo único y lo pone en nombre. La cadena nombre debe estar inicializada como "XXXXXX". Esta función no abre el fichero.

Devuelve: Si tiene éxito, un puntero a nombre. En caso contrario, un puntero nulo.

Portabilidad: Está disponible para sistemas UNIX.

rmdir

Prototipo: int rmdir (const char *directorio);

Include: dir.h

Propósito: Borra el directorio cuyo nombre se indica en directorio. Para poder borrar el directorio debe cumplirse que:

  • Está vacío

  • No es el directorio de trabajo

  • No es el directorio raíz

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1 y asigna a la variable global errno alguno de los valores siguientes:

EACCES Acceso denegado

ENOENT Encaminamiento no válido

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

searchpath

Prototipo: char *searchpath (const char *nombre);

Include: dir.h

Propósito: Busca el archivo nombre usando la variable de entorno PATH.

Devuelve: Si tiene éxito devuelve un puntero al encaminamiento completo. En caso contrario, devuelve un puntero nulo.

Portabilidad: Sólo DOS.

setdisk

Prototipo: int setdisk (int unidad);

Include: dir.h

Propósito: Establece como unidad activa la especificada mediante unidad (0=A, 1=B, ...).

Devuelve: El número de unidades disponible.

Portabilidad: Sólo DOS.

Funciones de control de procesos

abort

Prototipo: void abort (void);

Include: stdlib.h, process.h

Propósito: Muestra el mensaje Abnormal program termination en stderr y finaliza el programa, enviando al proceso padre un código de retorno 3. No cierra ningún archivo.

Devuelve:

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

Funciones exec

Prototipos: int execl (char *nom, char *arg0, ..., char *argN, NULL);

int execle (char *nom, char *arg0, ..., char *argN, NULL, char *entorno[ ]);

int execlp (char *nom, char *arg0, ..., char *argN, NULL);

int execlpe (char *nom, char *arg0, ..., char *argN, NULL, char *entorno[ ]);

int execv (char *nom, char *arg[ ]);

int execve (char *nom, char *arg[ ], char *entorno[ ]);

int execvp (char *nom, char *arg[ ]);

int execvpe (char *nom, char *arg[ ], char *entorno[ ]);

Include: process.h

Propósito: Las funciones exec ejecutan otros programas, llamados procesos hijo. Después de la llamada el proceso hijo sustituye al proceso padre en memoria, siempre que haya suficiente. El nombre del proceso hijo se especifica con el parámetro nom. Al proceso hijo se le pasan los argumentos individualmente mediante arg0, ..., argN, o bien en el vector arg[ ]. También se puede pasar una matriz de cadenas de entorno mediante el parámetro entorno[ ].

El proceso hijo es buscado siguiendo las siguientes normas:

  • Si nom no tiene incluida una extensión, se buscará un archivo con ese nombre. Si no se encuentra, se buscará el mismo archivo con extensión .COM. Si tampoco se encuentra, se buscará un archivo con extensión .EXE.

  • Si nom lleva incluida una extensión, sólo se buscará ese archivo.

La manera en que se ejecutan estas funciones dependen de qué versión de función exec se utilice. Las versiones se diferencian por los sufijos p, l, v y e que se pueden añadir al nombre. El significado de estos sufijos es el siguiente:

p Si la función tiene este sufijo, el proceso hijo se busca usando la variable de entorno PATH del DOS. En caso contrario la búsqueda se realiza sólo en el directorio de trabajo.

l Los argumentos se pasan individualmente mediante los parámetros arg0, ..., argN. El último argumento debe ser un NULL (definido en stdio.h).

v Los argumentos se pasarán en una matriz arg[ ].

e Se pasará una o varias cadenas de entorno mediante la matriz entorno[ ]. El último elemento de la matriz debe ser un NULL.

Las funciones exec deben pasar al proceso hijo al menos un argumento. Este argumento es, por convenio, nom, aunque cualquier otro no produce error.

Cuando se usa el sufijo l, arg0 apunta a nom, y arg1, ..., argN apuntan a la lista de argumentos que se pasan.

Cuando se usa el sufijo e, Las cadenas de la matriz entorno[ ] deben tener la forma

variable de entorno = valor

La suma de longitudes de los argumentos que se pasan no debe superar los 128 bytes (sin contar los nulos).

Las funciones exec no cierran ficheros.

Devuelve: En caso de error devuelve -1 y asigna a la variable global errno alguno de los valores siguientes:

E2BIG Demasiados argumentos

EACCES Acceso denegado al proceso hijo

EMFILE Demasiados ficheros abiertos

ENOENT Archivo no encontrado

ENOEXEC Error de formato en la función exec

ENOMEM Memoria insuficiente

Portabilidad: Sólo DOS.

exit

Prototipo: void exit (int st);

Include: process.h, stdlib.h

Propósito: Provoca la terminación del programa. Cierra todos los ficheros abiertos y descarga todos los buffers de salida. Envía al proceso padre un código de retorno st. Normalmente se envía un valor 0 para la terminación normal, y un valor diferente de 0 si se ha producido un error.

Devuelve:

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

Funciones spawn

Prototipos: int spawnl (int modo, char *nom, char *arg0, ..., char *argN, NULL);

int spawnle (int modo, char *nom, char *arg0, ..., char *argN, NULL, char *entorno[ ]);

int spawnlp (int modo, char *nom, char *arg0, ..., char *argN, NULL);

int spawnlpe (int modo, char *nom, char *arg0, ..., char *argN, NULL, char *entorno[ ]);

int spawnv (int modo, char *nom, char *arg[ ]);

int spawnve (int modo, char *nom, char *arg[ ], char *entorno[ ]);

int spawnvp (int modo, char *nom, char *arg[ ]);

int spawnvpe (int modo, char *nom, char *arg[ ], char *entorno[ ]);

Include: process.h

Propósito: Estas funciones son idénticas a las funciones exec, salvo en tres detalles:

En primer lugar, en las funciones spawn el proceso hijo no sustituye necesariamente al proceso padre en memoria.

En segundo lugar, se añade un nuevo parámetro, modo, que puede tener los siguientes valores:

P_WAIT Deja suspendida la ejecución del proceso padre hasta que termine el proceso hijo.

P_NOWAIT Ejecuta concurrentemente el padre y el hijo. No está disponible en Turbo C.

P_OVERLAY El proceso hijo sustituye al proceso padre en memoria.

La tercera diferencia está en cómo el proceso hijo es buscado. Se siguen las siguientes normas:

  • Si nom no tiene incluida una extensión ni un punto, se buscará un archivo con ese nombre. Si no se encuentra, se buscará el mismo archivo con extensión .COM. Si tampoco se encuentra, se buscará un archivo con extensión .EXE.

  • Si nom lleva incluida una extensión, sólo se buscará ese archivo.

  • Si nom tiene un punto se buscará sólo un fichero con ese nombre y sin extensión.

Devuelve: En caso de error devuelve -1 y asigna a la variable global errno alguno de los valores siguientes:

E2BIG Demasiados argumentos

EMFILE Demasiados ficheros abiertos

ENOENT Archivo no encontrado

ENOEXEC Error de formato en la función exec

ENOMEM Memoria insuficiente

Portabilidad: Sólo DOS.

Funciones de pantalla de texto

Ya se han estudiado las siguientes funciones en el Capítulo 4:

clreol

clrscr

delline

gotoxy

highvideo

insline

lowvideo

movetxt

normvideo

textattr

textbackground

textcolor

textmode

wherex

wherey

Otras funciones de pantalla de texto se muestran a continuación:

cprintf

Prototipo: int cprintf (const char *format [, argumento, ...]);

Include: conio.h

Propósito: Es prácticamente idéntica a printf. Las diferencias son:

  • Escribe en la ventana activa y no en stdout.

  • Impide que se superen los límites de la ventana.

  • No se puede redireccionar la salida.

  • Respeta los atributos de color actual.

  • No convierte la nueva línea (\n) en salto de línea + retorno de carro. Es preciso añadir \r.

Devuelve: El número de caracteres escritos.

Portabilidad: Sólo IBM-PC's y compatibles.

cputs

Prototipo: int cputs (const char *cadena);

Include: conio.h

Propósito: Es prácticamente idéntica a puts. Las diferencias entre puts y cputs son las mismas que entre printf y cprintf.

Devuelve: Si tiene éxito devuelve el último carácter escrito. En caso contrario, devuelve EOF.

Portabilidad: Sólo IBM-PC's y compatibles.

cscanf

Prototipo: int cscanf (const char *format [, direcc, ...]);

Include: conio.h

Propósito: Es idéntica a scanf salvo que lee la información de la consola en lugar de stdin. Respeta los atributos de color actual. No se puede redirigir.

Devuelve: El número de argumentos a los que realmente se les ha asignado valores.

Portabilidad: Sólo DOS.

gettext

Prototipo: int gettext (int izq, int arriba, int dcha, int abajo, void *dest);

Include: conio.h

Propósito: Almacena en dest un rectángulo de la pantalla de texto definido por las coordenadas izq, arriba, dcha y abajo. Las coordenadas son absolutas, no relativas a la ventana. La esquina superior izquierda está en (1,1). La copia se hace secuencialmente, es decir, de izquierda a derecha y de arriba hacia abajo. Cada posición en la pantalla ocupa 2 bytes en la memoria: el primero almacena el carácter y el segundo el atributo.

Devuelve: Si tiene éxito, devuelve 1. En caso contrario, devuelve 0.

Portabilidad: Sólo en IBM-PC's y en sistemas con BIOS compatible.

puttext

Prototipo: int puttext (int izq, int arriba, int dcha, int abajo, void *fuente);

Include: conio.h

Propósito: Escribe el contenido del área apuntada por fuente en el rectángulo de pantalla definido por las coordenadas izq, arriba, dcha y abajo. Generalmente el área fuente se ha llenado con una llamada a gettext.

Devuelve: Si tiene éxito, devuelve un valor diferente de 0. En caso contrario, devuelve 0.

Portabilidad: Sólo en IBM-PC's y en sistemas con BIOS compatible.

window

Prototipo: void window (int izq, int arriba, int dcha, int abajo);

Include: conio.h

Propósito: Define la ventana de texto activa. Las coordenadas izq, arriba son las de la esquina superior izquierda. Las coordenadas dcha, abajo son las de la esquina inferior derecha.

Devuelve:

Portabilidad: Sólo en IBM-PC's y compatibles.

Otras funciones

abs

Prototipo: int abs (int x);

Include: math.h, stdlib.h

Propósito: Obtiene el valor absoluto del entero x.

Devuelve: El valor calculado.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

atof

Prototipo: double atof (const char *cad);

Include: math.h, stdlib.h

Propósito: Convierte la cadena apuntada por cad en un double. Esta función reconoce la representación de un número en coma flotante con la siguiente estructura:

[blancos][signo][ddd][.][e|E[signo]ddd]

Cualquier carácter no admisible corta la entrada.

Devuelve: El valor calculado. Si se produce desbordamiento devuelve +/- HUGE_VAL y asigna a la variable global errno el valor ERANGE.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

atoi

Prototipo: int atoi (const char *cad);

Include: stdlib.h

Propósito: Convierte la cadena cad en un número entero. Esta función reconoce el formato:

[blancos][signo][ddd]

La entrada finaliza si se encuentra un carácter no válido.

Devuelve: El valor convertido. Si la conversión no es posible devuelve 0.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

atol

Prototipo: long atol (const char *cad);

Include: stdlib.h

Propósito: Convierte la cadena cad en un número long. Esta función reconoce el formato

[blancos][signo][ddd]

La entrada finaliza si se encuentra un carácter no válido.

Devuelve: El valor convertido. Si la conversión no es posible devuelve 0.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

itoa

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

Include: stdlib.h

Propósito: Convierte el entero valor en una cadena, y lo almacena en cad. El parámetro base especifica en qué base se realizará la conversión. Debe estar entre 2 y 36. Si valor es negativo y base es 10, el primer carácter de cad es el signo menos (-). El espacio asignado para cad debe ser suficientemente grande para almacenar el resultado. La función itoa puede devolver hasta 17 caracteres.

Devuelve: Un puntero a cad.

Portabilidad: Sólo DOS.

kbhit

Prototipo: int kbhit (void);

Include: conio.h

Propósito: Detecta si una tecla ha sido pulsada, sin retirar el carácter del buffer y sin detener el programa.

Devuelve: Si se ha pulsado una tecla devuelve un valor diferente de 0. En caso contrario devuelve 0.

Portabilidad: Sólo DOS.

labs

Prototipo: long int labs (long int x);

Include: math.h, stdlib.h

Propósito: Calcula el valor absoluto de x.

Devuelve: El valor calculado.

Portabilidad: Está disponible para UNIX y está definida en ANSI C.

ltoa

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

Include: stdlib.h

Propósito: Convierte el entero largo valor en una cadena, y lo almacena en cad. El parámetro base especifica en qué base se realizará la conversión. Debe estar entre 2 y 36. Si valor es negativo y base es 10, el primer carácter de cad es el signo menos (-). El espacio asignado para cad debe ser suficientemente grande para almacenar el resultado. La función ltoa puede devolver hasta 33 caracteres.

Devuelve: Un puntero a cad.

Portabilidad: Sólo DOS.

nosound

Prototipo: void nosound (void);

Include: dos.h

Propósito: Apaga el altavoz después de una llamada a sound.

Devuelve:

Portabilidad: Sólo IBM-PC's y compatibles.

random

Prototipo: int random (int num);

Include: stdlib.h

Propósito: Genera un número aleatorio entero entre 0 y num - 1.

Devuelve: El valor generado.

Portabilidad:

randomize

Prototipo: void randomize (void);

Include: stdlib.h, time.h

Propósito: Inicializa el generador de números aleatorios.

Devuelve:

Portabilidad:

_setcursortype

Prototipo: void _setcursortype (int tipocursor);

Include: conio.h

Propósito: Establece el aspecto del cursor. Los valores posibles para tipocursor son:

_NOCURSOR Desaparece el cursor

_SOLIDCURSOR Cursor de bloque ( * )

_NORMALCURSOR Cursor normal ( _ )

Devuelve:

Portabilidad: Sólo IBM-PC's y compatibles.

sound

Prototipo: void sound (unsigned ciclos);

Include: dos.h

Propósito: Activa el altavoz a una frecuencia de sonido de ciclos hertz (ciclos por segundo).

Devuelve:

Portabilidad: Sólo IBM-PC's y compatibles.

system

Prototipo: int system (const char *orden);

Include: stdlib.h, process.h

Propósito: Llama al intérprete de comandos (COMMAND.COM) del DOS para ejecutar la orden especificada mediante orden. Esta orden puede ser una orden DOS, un fichero .BAT o cualquier programa.

Devuelve: Si tiene éxito devuelve 0. En caso contrario devuelve -1.

Portabilidad: Está disponible para UNIX y está definida en ANSI C. Es compatible con K&R.

ultoa

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

Include: stdlib.h

Propósito: Convierte el unsigned long valor en una cadena, y lo almacena en cad. El parámetro base especifica en qué base se realizará la conversión. Debe estar entre 2 y 36. Si valor es negativo y base es 10, el primer carácter de cad es el signo menos (-). El espacio asignado para cad debe ser suficientemente grande para almacenar el resultado. La función ultoa puede devolver hasta 33 caracteres.

Devuelve: Un puntero a cad.

Portabilidad: Sólo DOS.