Vous êtes sur la page 1sur 50

apenf.

qxd 26/11/99 14:17 Página 615

APÉNDICE F

BIBLIOTECA DE FUNCIONES ESTÁNDAR


ANSI/ISO C++ Y BORLAND C++ 5.0

CONTENIDO

F.1. Plantilla referencia de entradas. F.8. Funciones de control de procesos.


F.2. Funciones de asignación de memoria. F.9. Funciones de conversión de datos.
F.3. Funciones de búsqueda y ordenación. F.10. Funciones de entrada/salida.
F.4. Funciones de cadena. F.11. Funciones de gestión de archivos.
F.5. Funciones de clasificación de caracteres. F.12. Funciones matemáticas.
F.6. Funciones de calendario (fecha y hora). F.13. Funciones de manipulación de bloques de memoria (buffers).
F.7. Funciones de control de directorios. F.14. Funciones de presentación de texto.

Esta parte es una revisión breve de la biblioteca de rutinas (funciones) y F.2. FUNCIONES DE ASIGNACIÓN DE MEMORIA
archivos include, en tiempo de ejecución. La biblioteca de Borland C++ es
un conjunto de más de 450 funciones y macros preparadas para utilizar y Borland C++ almacena información en la memoria principal de la compu-
diseñadas para su uso en programas C++. La biblioteca en tiempo de ejecu- tadora por dos métodos. El primero utiliza variables globales y locales
ción hace la programación más fácil, ya que incluye una amplia variedad de (incluyendo arrays, cadenas y estructura); en este caso, el almacenamiento
tareas tales como E/S de bajo y alto nivel, manipulación de cadenas y archi- o longitudes fija. Para cambiar el tamaño de arrays y cadenas de caracteres
vos, asignación de memoria, control de procesos, cálculos matemáticos, etc. se debe editar el archivo fuente y recompilar su programa. Esta información
Las rutinas de Borland C++ están contenidas en los archivos de bibliote- se almacena en la pila (stack). El segundo método de almacenar informa-
ca Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ imple- ción es asignar memoria a medida que el programa lo requiera y liberar esta
menta la versión estándar última de ANSI C, que entre otras cosas recomien- memoria cuando ya no se necesita; esta acción permite utilizar la misma
da el uso de los prototipos de función en las rutinas de sus programas C++.
Este apéndice describe alfabeticamente funciones de la biblioteca Bor-
land C++ y contiene todas las funciones incluidas en ANSI/ISO C++.
nombre función archivo de cabecera

F.1. PLANTILLA REFERENCIA DE ENTRADAS • strrev #include <string.h>


char *strrev(char *cad) sintaxis
Las entradas de las diferentes funciones y macros han sido normalizadas
para facilidad de manejo del lector. Las rutinas han sido clasificadas por Descripción
categorías (en general, se ha procurado respetar la clasificación dada por Propósito y breve descripción de cómo y dónde se utiliza la función.
Borland y ANSI, pero con una adaptación más próxima al uso diario del
Ejemplo
programador /.
Al comienzo de cada categoría se hace una breve descripción de su Una o más instrucciones o programas sencillos, donde se muestra la explicación
cometido principal y se presenta una tabla con las funciones que contiene real de la función.
cada categoría por orden alfabético, así como una breve síntesis de su des- Funciones relacionadas: strcpy, strncpy.
cripción o propósito. A continuación, por orden alfabético, se describen las Funciones relacionadas con la función descrita.
rutinas de acuerdo al siguiente modelo para cada entrada.
apenf.qxd 26/11/99 14:17 Página 616

616 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

memoria para colas diferentes en un tiempo distinto. Este proceso de asig- datos de un programa. Si hay éxito se devuelve 0; en caso contrario, –1, y la
nar memoria se denomina asignación dinámica de memoria. variable global errnoc toma el valor ENOMEN (insuficiente 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ódi- it(brk(nuevo_break) == -1)
go programa. DOS establece también un segmento de 64 Kb denominado perror(“brk ha fallado”);
segmento de datos. Su programa puede tener múltiples segmentos de datos
y códigos. Funciones relacionadas: free, farmalloc, malloc, sbrk.
El segmento de datos se divide en tres regiones: datos del programa
(variables estáticas y globales), pila —stack— (variables locales y argu-
mentos) y montón o montículo —heap. calloc #include <stdlib.h>
#include <alloc.h>
Segmento de datos
int *calloc(size_t n, size_t s);
Montículo Pila Datos del programa
(heap) (stack) Asigna memoria principal (un bloque de tamaño n.s). El bloque se
borra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debe
utilizar farcalloc. Devuelve un puntero al bloque recién asignado. Si no
Después de asignar partes del segmento de datos a variables estáticas y
existe bastante espacio para el nuevo bloque o bien n o s es 0, calloc
globales y a la pila, el compilador dedica el resto del segmento de datos al
devuelve nulo.
montículo o heap.
Borland C++ contiene un gran número de funciones para asignación long *buffer
dinámica de memoria, que realizan una gran variedad de tareas: asignar y buffer=(long *) calloc(40, sizeof(long));
liberar memoria del montículo y de la pila, obtener información de bloques
de memoria, etc. Funciones relacionadas free, malloc.

allocmen #include <dos.h>


coreleft #include <alloc.h>
int allocmen(unsigned t, unsigned * seg);
unsigned coreleft(void) // modelos small, tiny, medium
unsigned long coreleft(void); // en otros modelos de memoria
La función allocmen() establece seg para apuntar a un segmento asig-
nado 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 Determina la cantidad de memoria no utilizada. El valor devuelto
tamaño en párrafos del mayor bloque disponible. depende del modelo de memoria.
Mem_avail = coreleft();
if(allocmen(size, &segadd)!= -1)
printf (“Error asignación memoria \n”);
Funciones relacionadas: calloc, farcoreleft, malloc.
Funciones relacionadas: falloc frremem, malloc, setblock.

farcalloc #include <alloc.h>


brk #include <alloc.h>
void far *farcalloc(unsigned long n, unsigned long s);
int brk( void* a)
Esta función asigna n piezas de tamaño s y las pone a 0. Un puntero al
La función brk permite modificar el «valor break» de un programa. El principio de la memoria asignada se devuelve si farcalloc() tiene éxito;
valor break es la dirección de la primera posición más allá del segmento de en caso contrario se devuelve NULL.
apenf.qxd 26/11/99 14:17 Página 617

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 617

if(array_grande=farcalloc(20000L, sizeof (int)) “” NULL) Funciones relacionadas: farheapfillfree, farheapwalk, heapfill-


printf (“Fallo en asignación de memoria\n”); free, heapcheckfree, heapwalk.

Funciones relacionadas: calloc, farfree, farmalloc, malloc.


farheapchecknode #include <alloc.h>

farcoreleft #include <alloc.h> int farheapchecknode(void *bloque);

unsigned long farcoreleft(void); Verifica la consistencia de un solo bloque en el montículo (heap) far.
Determina el número total de bytes disponibles en el sistema. estadoheap = farheapchecknode(arraygrande);

memoria_total_disponible = farcoreleft();
farheapfillfree #include <alloc.h>
Funciones relacionadas: coreleft, farcalloc, farmalloc.
int farheapfillfree(unsigned int f);

farfree #include <alloc.h> Rellena todos los bloques libres del montículo far con un valor constante.

void farfree(void far *b); estadoheap = farheapfillfree(´X´);

Funciones relacionadas: farheapcheckfree, farheapchecknode,


Libera la memoria apuntada por b.
farheapwalk, heapfillfree, heapwalk.
farfree(arraygrande);

Funciones relacionadas: farcalloc, farmalloc, farrealloc, free. farheapwalk #include <alloc.h>

int farheapwalk(struct farheapinfo *m);


farheapcheck #include <alloc.h>
Obtiene información sobre las entradas en el montículo (heap) far.
int farheapcheck(void); struct farheapinfo heap_entry;
estadopila = farheapwalk(&heap_entry);
Verifica la consistencia del montículo (heap) far.

estadoheap = farheapcheck(); farmalloc #include <alloc.h>


Funciones relacionadas: farheapcheckfree, farheapchecknode,
void far *farmalloc(unsigned long n);
farheapwalk, heapfillfree, heapwalk, heapcheck.
Asigna n bytes de memoria far. La cantidad completa de memoria
encima de la pila está disponible para asignación por farmalloc. El tamaño
farheapcheckfree #include <alloc.h>
del bloque puede exceder de 64 Kb.
int farheapcheckfree(unsigned int f); if(bloquegrande = farmalloc(80000L) == NULL
Verifica la consistencia de los bloques libres en el montículo (heap) far. printf(“Asignación fallada\n”);

estadoheap = farheapcheckfree(´F´); Funciones relacionadas: calloc, farfree, farcalloc, malloc.


apenf.qxd 26/11/99 14:17 Página 618

618 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

farrealloc #include <alloc.h> heapcheckfree #include <alloc.h>

void far *farrealloc(void far *b, unsigned long n) int heapcheckfree(unsigned int f);

Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b, Verifica la consistencia de los bloques libres en el montículo (heap).
al cual se ha asignado una longitud de n bytes).
estadoheap = heapcheckfree(´N´);
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL
printf(“Fallo reasignación memoria\n”); Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.

Funciones relacionadas: calloc, farcalloc, farfree, malloc.


heapchecknode #include <alloc.h>

free #include<alloc.h> int heapchecknode(void *n);


#include <stdlib.h>
Verifica la consistencia de un solo nodo (bloque de memoria). Verifica
vid free(void *dir_memoria); el bloque de memoria identificado por el puntero n.

La función free() libera un bloque de memoria. El argumento estadopila = heapchecknode(array);


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 llama- Funciones relacionadas: farheapchecknode, heapcheck, heapcheck-
da el bloque libre está disponible para asignación. free, heapfillfree, heapwalk.

char *cad;
// asignar memoria para cadena heapfillfree #include <alloc.h>
cad = (char *) malloc(50);
int heapfillfree(unsigned int f);
...
free(cad); // liberar memoria Rellena cada byte de todos los bloques de memoria no utilizados en el
montículo con un valor de carácter especificado. En Visual C++ la función
Funciones relacionadas: calloc, malloc, realloc equivalente es –heapset.

estadopila = heapfillfree(´Z´);
heapcheck #include <alloc.h>
Funciones relacionadas: farheapfillfree, heapcheck, heapcheck-
int heapcheck(void); free, heapwalk.

Verifica la consistencia del montículo (heap). En Visual C++ 6.0 la fun-


ción equivalente es _heapcheck(); heapwalk #include <alloc.h>

estadoheap = heapcheck(); int heapwalk(struct heapinfo *i);

Funciones relacionadas: heapcheckfree, heapchecknode, heapfill- Se utiliza para obtener información sobre las entradas en el montículo
free, heapwalk, farheapcheck. (heap). La función equivalente en Visual C++ es _heapwalk.
apenf.qxd 26/11/99 14:17 Página 619

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 619

struct heapinfo i;
setblock #include <alloc.h>
estadoheap = heapwalk(&i);
int setblock(unsigned seg, unsigned n);
Funciones relacionadas: farheapwalk, heapcheck.
Ajusta el tamaño de un bloque de memoria asignado anteriormente por
allocmen. Esta función llama a la función 4Ah de DOS para ampliar el
malloc #include <stdlib.h>
tamaño de un bloque de memoria previamente asignado por allocmen. En
#include <alloc.h>
las versiones Visual C++ la función equivalente es _dos_setblock.
void *malloc (size_t n);
F.3. FUNCIONES DE BÚSQUEDA Y ORDENACIÓN
Asigna memoria a bloques en el montículo. Devuelve un puntero, que
es la dirección inicial de la memoria asignada. La mayoría de los programas requieren casi siempre alguna operación de
clasificación y búsqueda de elementos en arrays. Borland C++ incluye dife-
cadena = malloc(MAX_CHR)
rentes funciones que realizan estas tareas.
Funciones relacionadas: calloc, free, realloc.
bsearch() #include <stdlib.h>

realloc #include <alloc.h>


void bsearch(const void*k, const void *b, size_t n, size_t a,
#include <stdlib.h>
int(*comparar)(const void*, const void*));

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


La función bsearch realiza una búsqueda binaria en un array ordena-
do b, de n elementos, cada uno de a bytes de tamaño. El argumento k apun-
Ajusta el tamaño de un bloque de memoria b asignado por malloc o ta al valor que se está buscando. bearch devuelve un puntero (la dirección)
calloc a un tamaño de n bytes. Devuelve un puntero void al bloque de
a la primera aparición del valor k en el array. Si no se encuentra el valor,
memoria reasignado. bsearch devuelve o.
El argumento comparar proporciona la dirección de una rutina que
Nuevo_buffer = realloc(viejo_buffer, long+100);
aceptará dos argumentos elem1 y elem2, cada uno un puntero a un elemen-
to del array. La función comparar compara cada uno de los elementos apun-
Funciones relacionadas: calloc, free, malloc. tados y devuelve un valor de acuerdo con la tabla siguiente:

sbrk #include <alloc.h> Valor devuelto Condición

void *sbrk(int n);


Negativo Primer elemento menor que el segundo (elem1) (elem2).
Cero Los dos elementos son idénticos.
Se utiliza sbrk para indicar el valor break de un proceso. El valor Positivo Primer elemento mayor que el segundo.
break es la dirección del primer byte disponible en el segmento de datos por
omisión, más allá del segmento de datos que está siendo utilizado por los
datos en el proceso. 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
sbr(500); para ordenar el array antes de llamar a bsearch.

Funciones relacionadas: brk, coreleft Funciones relacionadas: lfind, lsearch, qsort.


apenf.qxd 26/11/99 14:17 Página 620

620 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

lfind #include <stdlib.h> Valor devuelto Condición

void * lfind(const void k, const void *b, size_t *num, size_t


Negativo Primer elemento (elem1) menor que el segundo (elem2).
anchura, int(*comparar)(const void*, const void*)); Cero Los dos elementos son idénticos.
Positivo Primer elemento mayor que el segundo.
La función lfind() realiza una búsqueda lineal de valor de k (clave) en
un array de un número específico de elementos, cada uno de un número fijo
de bytes de longitud. Al contrario que bsearch(), el array no necesita
estar ordenado. lfind() devuelve un puntero al primer elemento del array Ordenar la lista de enteros y visualizar el resultado.
que coincide con la clave; si la clave no existe en el array, se devuelve un 0.
#include <stdlib.h>
int comp(const void*, const void *); resultado = (char **) #include <stdio.h>
lfind(palabrabuscada, envp, &cuenta, sizeof(char*), comp);
int comparar(const void*, const void *);
Funciones relacionadas: bsearch, lsearch, qsort. int numeros[10] = {4,5,7,3,12,8,6,1,0,2};

main(void)
lsearch #include <stdlib.h> {
int i;
void * lsearch(const void *k, const void *a, size_t *n, size_t W,
int(*comparar) (const void*, const void *)); printf(“lista original:”);
for(i =0; i < 10; i++)
La función lsearch realiza una búsqueda lineal de la clave k. El printf(“%d”, numeros[i]);
array a contiene n elementos de anchura W. La función comparar se uti- qsort(numeros,10,sizeof(int), comparar);
liza para comparar la clave con el elemento actual del array. Al contrario printf(“lista ordenada:”);
for(i = 0; i < 10; i++)
que bsearch(), en la función lsearch() el array no tiene que estar printf(“%10, numeros[i]);
ordenado. lsearch() devuelve un puntero al primer elemento del array return 0;
que se corresponde con la clave. Si no existe la clave en el array, se }
devuelve 0 y un registro se añade al array con un valor de k.
La diferencia entre lsearch() y lfind() es que lsearch() añadirá // comparar enteros
un registro al final del array con un valor de la clave si ese registro no se ha comparar(const void *i, const void *j)
encontrado en el array. {
return ((int *)i) – ((int *) j)
Funciones relacionadas: bsearch, lfind, qsort. }

Funciones relacionadas: bsearch, lfind, lsearch.


qsort #include <stdlib.h>

void qsort(void a, size_t n, size_t w, int(*comparar) (const void*, F.4. FUNCIONES DE CADENA
const void*));
C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan
La función qsort ordena un array con un número dado de elementos como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación
utilizando el método de ordenación rápida quicksort (creado por C.A.R. el final de una cadena en C se representa por un byte que contiene un carácter
Hoare). El número de elementos de array es n y el tamaño (en bytes) de cada nulo (´\0´). Las cadenas pueden ser declaradas como arrays de caracteres.
elemento es w. La función comparar se utiliza para comparar un elemento
del array con la clave; devuelve los siguientes valores: char cad[20], cad 5[] = “Hola Mortimer”;
apenf.qxd 26/11/99 14:17 Página 621

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 621

Acceso a las cadenas strchr #include <string.h>

A las cadenas se accede directamente a través de su índice, como en el char *strchr(const char *cad, int c);
ejemplo anterior, o bien a través de un puntero.
strchr() encuentra la primera aparición de c en cad y devuelve un
char cad5[] = “Hola Mortimer”; puntero a la primera aparición de c en cad. Si c no se encuentra, devuelve
char *p_cad5; un cero (NULL).
p_cad5 = cad5;
printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));
Se puede también declarar e inicializar una cadena a la vez:
visualizará $85725
char *p_cad5 = “Hola Mortimer”;
char *s[81] = “Esta es una cadena de prueba”;
char *ptr;
El archivo de cabecera <string.h> contiene numerosas funciones que ptr = strchr(s, ´a´);
manipulan cadenas.
el valor almacenado en ptr es un puntero a la primera aparición de ´a´.

stpcpy #include <string.h>


strcmp #include <string.h>
char *stpcpy(char *cad1, const char *cad2);
int strcmp(const char *a, const char *b);
La función stpcpy() copia una cadena en otra. Devuelve un puntero al
final de la cadena copiada. Se devuelve el valor de cad1+strlen(cad2) Compara una cadena con otra. Los resultados serían:
stpcpy(orden_dos, “DIR”); > 0 si a > b
stpcpy(caad1, cad2); = 0 si a == b
< 0 si a < b
Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.
i = strcmp(“MNP”, “mnp”); // resultado < 0
i = strcmp(“abc”, “abc”); // resultado = 0
i = strcmp(“xy”, “abc”); // resultado > 0
strcat #include <string.h>
char s1[80] “ “Mayo”;
char *strcat(char *cad1, const char cad2); char s2[80] = “Octubre”;
int j;
strcat() concatena (añade) cad1 al final de cad2, terminando la cade- j = strcmp(s1, s2);
na resultante con un carácter nulo (\0).
Funciones relacionadas: strcmpi, stricmp, strnicmp, strncmp.
char nombre[80] = “Bob”;
char blanco[2] = “”;
char ultimo[80] = “Marley”;
... strcmpi #include <string.h>
strcat(nombre,blanco); // blanco se concatena a nombre
strcat(nombre,ultimo); // ultimo se concatena a nombre int strcmpi(const char *cad1, const char * call2);
// la cadena nombre será “Bob Marley”
Compara una cadena con otra sin diferenciar entre mayúsculas y minús-
Funciones relacionadas: strcpy, strdup, strncat, strncpy. culas y devuelve un entero:
apenf.qxd 26/11/99 14:17 Página 622

622 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

< 0 si cad1 < cad2 ce del primer carácter de cad1, que pertenece al conjunto de caracteres de
= 0 si cad1 = cad2 cad2.
> 0 si cad1 > cad2
primero = strcspn(“circunloquio”, “q”);
v = strcmpi(c1, c2);
// primero = 8
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.
Funciones relacionadas: strpbrk, strspn.

strcoll #include <string.h>


strdup #include <string.h>
int strcoll(const char *cad1, const char cad2);
char * strdup(const char *cad);
Compara cad1 con cad2. Devuelve un valor.
Asigna memoria y copia una cadena dada en ese espacio. En realidad,
< 0 si cad1 < cad2 strdup() llama a malloc para asignar suficiente memoria para contener a
= 0 si cad1 = cad2 cad. Si falla la asignación de memoria, strdup() devuelve un carácter nulo
> 0 si cad1 > cad2 (NULL).
Leer una cadena y hacer un duplicado.
if(strcoll(nombre1, nombre2)! = 0)
exit(EXIT_FAILURE); #include <stdio.h>
#include <string.h>
Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp, main()
strxfrm. {
char cad1[80], * cad1_copia;
printf(“Introduzca una cadena:”);
gets(cad1);
strcpy() #include <string.h> cad1_copia = strdup(cad1);
printf(“La cadena duplicada es:%s\n”, cad1_copia);
char *strcpy(char *cad1, const char *cad2); return 0;
}
strcpy() copia cad2 en cad1. Si la longitud de la cadena resultante
excede el tamaño asignado a cad1, puede producir fallos en el programa.
strerror #include <string.h>
char *a = “Pepe Luis”;
char b[12];
char *strerror(int errnum);
strcpy(b, a);
cout << b << ´\n´;
Obtiene el mensaje de error del sistema correspondiente al número dado
Funciones relacionadas: strcat, strcup, strncat, strncpy. en el argumento errnum. La función strerror() obtiene el mensaje de
error del sistema utilizando el valor en la variable global errno, como el
índice una tabla de errores denominadas sys_errlist, que está declarado
strcspn #include <string.h> en el archivo de cabecera stdlib.h.

size_strcspn(const char *cad1, const char *cad2); errno = 0;


printf (“Error”, strerror(errno);
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 índi- Funciones relacionadas: perror, _strerror.
apenf.qxd 26/11/99 14:17 Página 623

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 623

strerror #include <string.h> strlwr #include <string.h>


#include stdio.h
char *strlwr(char *cad);
char *strerror(const char *cad);
Convierte una cadena en letras minúsculas. La función devuelve un
Esta función sirve para generar un mensaje de error definido por el puntero a la cadena convertida.
usuario.
char *orden =”SALIR”;
printf(“%S”, _strerror(“error apertura archivo”)); strlwr(orden); // ahora orden = “salir”;

Funciones relacionadas: perror, strerror. Funciones relacionadas: strupr, toloweer.

stricmp #include <string.h> strncat #include <string.h>

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

Esta función se utiliza para comparar una cadena a otra sin tener en La función strncat() añade los primeros n caracteres de cad2 a cad1,
cuenta el tamaño de las letras. Convierte todos los caracteres alfabéticos de y termina la cadena resultante un carácter nulo. Si cad2 es mayor que n
cad1 y cad2 en minúsculas; a continuación, se comparan las dos cadenas y caracteres de longitud, strncat() truncará la cadena a la longitud de n. En
devuelve un valor entero que indica el orden lexicográfico de cad1 con res- otro caso, concatenará la cadena completa.
pecto a cad2.
char *a = “Sierra Madre”;
Si cad1 = cad2 el valor de la función es cero. char *b = “de la ciudad de Monterrey”;
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. cout << strncat(a, b, 4) << ´\n´;
cout << strncat(a, b) << ´\n´;
Resultado = stricmp(cad1, cad2),
Funciones relacionadas: strcat, strdup, strcpy, strncpy.
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.

strncmp #include <string.h>

strlen #include <strign.h>


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

size_t strlen(const char *cad);


Compara un número especificado en caracteres de dos cadenas y
Proporciona la longitud de una cadena cad. El carácter nulo no se inclu- devuelve un entero con un valor.
ye en la longitud; en consecuencia, cuando reserve espacio, recuerde añadir
< 0 si cad1 < cad2
1 al valor devuelto por strlen. = 0 si cad1 < cad2
> 0 si cad1 < cad2
longitud = strlen(nombre);
char s[81] = “Cadena demo”; char *a = “Mortimer el andaluz”;
printf(“La longitud de s es:%d\n” strlen(s)); char *b = “Mortimer el mexicano”;

Funciones relacionadas: _fstrlen. if((strncmp(a, b, 8)) == 0)


apenf.qxd 26/11/99 14:17 Página 624

624 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

cout << “Ambas cadenas comienzan con \Mortimer\”; Encuentra la última aparición del carácter c en cad. Devuelve un pun-
else teo a la última aparición de c o un carácter nulo si c no está en cad.
cout << “Estas cadenas no comienzan con \Mortimer\”;
char *nombrearch = “c: /usr/tst/libro/cap1.txt”;
Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, str- cout << (strrchr(nombrearch, ´/´)+1 << ´\n´;
nicmp.
Funciones relacionadas: strchr.
strnset #include <string.h>

char *strnset(char *cad, int c, size_t n); strrev #include <string.h>

Inicializa los caracteres de una cadena a un valor dado (blanco u otro char *strrev(char *cad);
carácter). Devuelve un puntero a la cadena cad. El carácter c se utiliza para
rellenar la cadena con ese carácter; n es el número de posiciones de carac- Invierte los caracteres de la cadena cad. El carácter de terminación nulo
teres que se han de inicializar. permanece en el mismo lugar. strrev() devuelve un puntero a la cadena
inversa.
printf(“Introduzca una cadena:”); Aplicación: Invertir una cadena leída del teclado e imprimir el resultado.
gets(cadena);
printf(“Introducir un carácter:”); #include <stdio.h>
c = getche(); #include <string.h>
long = strlen(cadena)/2; main()
strnset(cadena, c, lon); {
char demo[80]
printf(“Introduzca una cadena:”);
Funciones relacionadas: memset, setmem, strset. gets(demo);
strrev(demo);
printf(“La cadena inversa es:\n %s |\n”, demo);
strpbrk #include <string.h> return 0;
}
char *strpbrk(const char *cad1, const char *cad2);
Funciones relacionadas: strcpy, strncpy.
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).
strset #include <string.h>
char *s = “Mortimer L.J. Mackoy”;
char *p = strpbrk(s, “L4”); char *strset(char *cad, int c);
cout << p << ´\n´; // la salida es L.J.Mackoy
Establece todos los caracteres de la cadena cad al valor de c. Termina
Funciones relacionadas: strchr, strcspn. cuando se encuentra el primer carácter nulo. Devuelve un puntero a la cade-
na modificada.

char *cad = “-----”;


strrchr #include <string.h> strset (cad, ´x´); // cad es ahora xxxxx

char *strrchr(const char *cad, int c); Funciones relacionadas: strnset.


apenf.qxd 26/11/99 14:17 Página 625

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 625

strspn #include <string.h> Convierte cualquier letra minúscula de la cadena en mayúscula y


devuelve un puntero a la cadena convertida (sólo alfabeto inglés).
sze_t strspn(const char *cad1, constchar *cad2); La función strupr y su homónima strlwr no forman parte de la biblio-
teca ANSI C. En estos casos, utilice las funciones toupper y tolower.
Localiza la posición del primer carácter de una cadena (cad1) que no
pertenece al conjunto de caracteres de otra (cad2). strupr(“sierra madre”); // “SIERRA MADRE”

loc = strspn (cad1, blanco); Funciones relacionadas: strlwr, toupper.


Funciones relacionadas: strcmp, strcspn.
strxfrm #include <string.h>

strstr #include <string.h> size_t strxfrm(char *cad1, char *cad2, size_t n);

char *strstr(const char *cad1, const char *cad2); Convierte cad2 en cad1 basado en información específica local y con
un número máximo de caracteres a situar en cad1 de n. En el siguiente
Localiza la primera aparición de una cadena en otra. Si tiene éxito, la ejemplo, strxfrm transforma los tres primeros caracteres de cad1 en los
función strstr devuelve un puntero a la primera aparición de cad2 como tres primeros caracteres de cad2.
una subcadena de cad1. Si la búsqueda falla, se devuelve NULL.
char *cad1 = “abcdefg”;
char *s = “Mi autor favorito es Octavio Paz” char *cad2 = “1234567”;
char *a = “Octavio Paz”;
cout << “La subcadena” << a << “se encuentra:” clrscr();
<< strstr(s, a) << ´\n´; strxfrm(cad1, cad2, 3);
printf(“Transformada: %s\n”, cad1);
Funciones relacionadas: strchr, strcspn, strpbrk

strtok #include <string.h> F.5. FUNCIONES DE CLASIFICACIÓN


DE CARACTERES
char *strtok(char *cad1, const char *cad2);
C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita deter-
Rompe una cadena en subcadenas (token) utilizando una lista de sepa- minar la categoría de un carácter o convertir un carácter de mayúsculas en
radores. Devuelve un puntero a la subcadena actual y un NULL cuando se minúsculas, o viceversa. La biblioteca C contiene funciones que pueden ser
alcanza el final de la cadena. definidas como macros para estos propósitos. Las macros están definidas en
char *s = “¿Prefiere a Verdi, o a Pucini?”;
el archivo de cabecera ctype.h.
char *t = “.,!* ”; Las macros de clasificación sirven para determinar qué clase de valor
cout << strtok(s, t) << ´\n´; contiene una variable carácter. Puede necesitar conocer esta característica
cout << strtok(NULL, “!”); 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—
Funciones relacionadas: strpbrk, strcspn. 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
strupr #include <string.h> 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
char *strupr(char *cad); usuario, se pueden utilizar las macros de clasificación.
apenf.qxd 26/11/99 14:17 Página 626

626 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Asimismo, existen otras funciones en el archivo ctype.h que sirven iscntrl, isdigit #include <ctype.h>
para convertir caracteres en mayúsculas en minúsculas, y viceversa; y valo- isgraph, islower
res enteros en códigos ASCII. isprint, ispunct, isspace
isupper,isxdigit

isalnum #include <ctype.h> int iscntrl(int c);


int isdigit(int c);
int isalnum(int c);
int isgraph(int c);
La función isalnum() devuelve un cero si c es un carácter no alfa- int islower(int c);
numérico y un valor distinto de cero si el carácter es alfanumérico. int isprint(int c);
int ispunct(int c);
carac = getch(); int isspace(int c);
if(isalnum(carac)) int isupper(int c);
printf(“%c letra|digito \n”, carac); int isxdigit(int c);
else
printf(“%c no letra|digito \n”, carac);
Estas macros sirven para determinar propiedades específicas de un
Funciones relacionadas: isascii. carácter ASCII.

isalpha #include <ctype.h> Macro Verifica Rango válido de valores

int isalpha(int c); iscntrl Carácter de control. 0..1Fh, 7Fh


isdigit Dígito decimal. ´0´..´9´
La función isalpha() verifica si un carácter es alfabético. Devuelve un isgraph Carácter imprimible (sin espacio). 21h a 7Eh
valor distinto de cero si c es un carácter alfabético, o 0 si c no es alfabético. islower Carácter minúscula. ´a´..´z´´
isprint Carácter imprimible 20h..7Eh
int c = getah() ispunct Carácter puntuación 21h..2Fh, 3Ah..40h,
if(isalpha©) printf(“%c es letra\n”, c); 5Bh..60h, 7Bh..7Eh
isspace Carácter blanco. 9h..Dh 0 20h (blanco)
Funciones relacionadas: iascii. isupper Carácter mayúscula. ´A´..´Z´
isxdigit Dígito hexadecimal. ´0´..´9´
´A´..´F´
isascii #include ctype.h> ´a´.. f´

int isascii(int c);

Comprueba si un carácter c es un carácter ASCII; c está en el rango 0-127. Cada macro (función) devuelve un valor distinto de cero si c satisface
Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII. el criterio de esa macro; en caso contrario, devuelve un cero.
carac = getch();
if(isascii(carac)) if(isprint(c)) printf(“\n %c imprimible\n”, c);
printf(“%c es ASCII \n”, carac); if(iscntrl(c)) printf(“%c es un carácter de control\”, c);
else if(isdigit(c)) printf(“%c es un dígito\n”, c);
printf(“%c no es ASCII \n”, carac); if(islower(c)) printf(“%c es letra minúscula\n”, c)

Funciones relacionadas: toascii, isalnum, isdigit, Funciones relacionadas: iascii.


apenf.qxd 26/11/99 14:17 Página 627

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 627

toascii #include <ctype.h> F.6. FUNCIONES DE CALENDARIO (FECHA Y HORA)


int toascii(int c); Las funciones de calendario (fecha y hora) permiten obtener la hora actual
y, a continuación, convertirla y almacenarla de acuerdo a sus necesidades
Esta función convierte un valor entero en un carácter ASCII válido. particulares. La hora actual se toma siempre de la hora del sistema. Las fun-
ciones de calendario están incluidas en el archivo de cabecera time.h.
C = toascii(entero);

Funciones relacionadas: iascii. asctime #include <time.h>

char *asctime(const struct tm *hora);


_tolower
tolower #include <ctype.h> Convierte la fecha y la hora almacenada en una estructura de tipo tm en
una cadena de caracteres. La estructura tm se define en time.h así:
int _tolower(int c);
int tolower(int c); struct tm
{
Convierte un carácter mayúscula en minúscula. Utilice _tolower sólo int tm_sec; // [0,59], segundos
cuando esté seguro de que el carácter que quiere convertir es una letra int tm_min; // [0,59], minutos
int tm_hour; // [0,23], horas
mayúscula.
int tm_mday; // [1,31], dias del mes
La función _tolower() sólo está disponible en sistemas UNIX. Por int tm_mon; // [0,11], mes del año
consiguiente, para asegurar la compatibilidad utilice sólo la función tolo- int tm_year; // [desde 1900], año
wer(). int tm_wday; // [0,6], dias desde domingo
int tm_yday; // [0,265], numero dia año
c = tolower(´S´); // c se convierte en ´S´ int tm_isdst; // indicador hora de verano
};
Funciones relacionadas: iascii, _toupper, toupper.
printf(“Fecha/hora es %s\n”, asctime(&reloj));

Funciones relacionadas: ctime, gmtime, clocaltime, strftime,


_toupper
time.
touper #include <ctype.h>

int _toupper(int c);


int _toupper(int c); clock #include <time.h>
int c; // carácter a convertir
cock_t clock(void);
Estas funciones convierten un carácter minúscula en mayúscula. Utili-
ce _toupper sólo cuando esté seguro de que el carácter que quiere conver- Calcula el tiempo empleado por el proceso llamador, es decir, el tiem-
tir es una letra minúscula (rango a-z). po utilizado de procesador. Devuelve un valor en ticks que ha de dividirse
La macro _toupper no está disponible en ANSI C. Para asegurar la por la constante CLK_TCK para obtener el tiempo transcurrido en segundos.
compatibilidad, utilice siempre toupper().
clock_t inicio, fin;
c = toupper(´S´); // c se convierte en ´S´ printf(“Inicio:%f\n, clock()/CLK_TCK;

Funciones relacionadas: iascii, _tolower, tolower. Funciones relacionadas: gettime, time.


apenf.qxd 26/11/99 14:17 Página 628

628 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

ctime #include <time.h> ftime #include <sys/timeb.h>

char *ctime(const time_t *hora); void ftime(struct timeb *ptrhora);

Convierte la fecha y hora almacenada como valor de tipo time_t en una Obtiene la hora actual y la almacena en la estructura timeb apuntada
cadena de caracteres (mes día hora año\0). por ptrhora.
struct timeb {
time_t hora;
long time; // segundos desde 00:00:00 hora GMT
hora = time(NULL);
short millitm; // milisegundos
printf(“Hora actual=%s\n”, ctime(&hora)); short timezone; // diferencia en minutos
// hora Greenwich y hora local
Funciones relacionadas: asctime, ftime, strtime, time. short dstflag; // hora de verano, ahorro de luz
};

difftime #include <time.h> ftime(&hora);

Funciones relacionadas: time tzset.


double difftime(time_t hora2, time_t hora1);

Obtiene la diferencia entre dos tiempos en segundos. getdate #include <dos.h>


time_t inicio, fin
void getdate(struct date *f);
clrscrl();
inicio = time(NULL);
delay (5000); Obtiene la fecha del sistema. Los componentes se almacenan en la
fin = time(NULL); estructura date definida en dos.h.
printf(“Diferencia en segundos: %f\n”,
difftime(inicio, fin)); struct date {
int da_year; // año actual (1980-2099)
Funciones relacionadas: asctime, ctime, gmtime, localtime, char da_day; // dia mes (1-31)
tzset. char da_mon; // mes (1-12)
};

struct date fecha;


dostounix #include <dos.h>
getdate(&fecha);

long dostounix(struct date *f, struct time *h); Funciones relacionadas: dostounix, gettime, setdate, settime.
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en
formato UNIX. gettime #include <dos.h>
time_t t;
struct time dos_hora; void gettime(struct time *t);
struct date dos_fecha;
gatdate(&Dos_hora); Obtiene la hora actual del sistema. Los componentes de la hora se alma-
gettime(&dos_fecha); cenan en la estructura time definida en dos.h.
t = dostounix(&dos_fecha, &dos_hora);
struct time {
Funciones relacionadas: ctime, gatdate, gettime. unsigned char ti_min // minutos (0-59)
apenf.qxd 26/11/99 14:17 Página 629

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 629

unsigned char ti_hour // horas (0-23)


setdate #include <dos.h>
unsigned char ti_hund // centésimas de segundo (0-99)
unsigned char ti_sec // segundos (0-59)
}; void setdate(struct date *f);

struct time hora; Cambia la fecha actual del sistema. Los componentes de la fecha (día,
gettime(&hora); mes. Año) se especifican en los campos de la estructura date.
Funciones relacionadas: dostounix, getdate, setdate, settime. struct date {
int da_year; // año actual
char da_day; // día mes
char da_mon; // mes, 1 para enero, 2...
gmtime #include <time.h> };

struct tm *gmtime (const time_t *hora); En Visual C++ la función equivalente es _dos_setdate.

Convierte la fecha y hora en el tiempo medio de Greenwich (GMT) setdate(&fecha);


(año, mes, día, hora, minutos, segundos y otros campos). Véase struct tm
en asctime. Funciones relacionadas: getdate, gettime, settime, dostounix.

ahora = gmtime(&hoy);
settime #include <dos.h>
Funciones relacionadas: asctime, ctime, ftime, localtime, time.
void settime(struct time *h);

Cambia la hora actual del sistema. Los componentes de la hora —hora,


localtime #include <time.h> minutos y segundos— se deben cargar en los campos apropiados de la
estructura time definida en dos.h. Véase gettime.
struct tm *localtime(const time_t *hora);
settime(&hora);
Convierte una fecha y hora en varios campos de una estructura de tipo
tm. Véase struct tm en asctime. Funciones relacionadas: dostounix, gatdate, gettime, setdate.

tiempoactual = localtime(&ahora);
stime #include <time.h>
Funciones relacionadas: asctime, gmtime, time.
int stime(time_t *t);

mktime #include <time.h>


Establece la fecha y hora del sistema al valor contenido en la posición
cuya dirección está en el argumento t.
time_t mktime(struct tm *h);
time_t horasis;
horasis = time(NULL);
Convierte la hora local a un valor de calendario. Véase struct tm en stime(&horasis);
asctime. printf(“segundos desde 1/1/70 %ld”, horasis);

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


apenf.qxd 26/11/99 14:17 Página 630

630 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

strftime #include <time.h> Convierte a formato DOS un valor de hora en el formato UNIX.

size_t strftime(char *cad, size_t maxlon, tnixtodos(t_unix, &d_dos, ft_dos);


const char *formato, const struct tm *t);
Funciones relacionadas: getdate, gettime, time, setdate, settime.
Convierte un puntero en una estructura tm en una cadena cad (con una
longitud máxima de n), utilizando f para dar formato a la cadena. El forma-
to es similar a printf().
F.7. FUNCIONES DE CONTROL DE DIRECTORIOS
horaseg = time(NULL);
horaactual = localtime(&horaseg); MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerárquico que
strftime(buffer, 80, “%A %B %d 19%y:I:%M, horaactual); permite al usuario organizar sus archivos en directorios y subdirectorios.
Las funciones de control de directorios en Borland C++ proporcionan las
Funciones relacionadas: asctime, ctime, gmtime, localtime, herramientas necesarias para crear, modificar, mover y eliminar directorios
time. desde sus programas C. Las funciones de manipulación de directorios resi-
den en el archivo de cabecera dir.h.

time #include <time.h>


chdir #include <dir.h>
time_t time(time_t *h);
int chdir(const char *camino);
Proporciona el tiempo del sistema en segundos desde las 00:00:00 de
1/1/1970 tiempo GMT. Cambia el directorio de trabajo actual al directorio especificado en el
argumento camino. La función devuelve un 0 si tiene éxito; en caso contra-
time(&hora); rio, 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).
tzset #include <time.h>
if(chdir(\\)) {
perror(“chdir()”);
void tzset(void);
exit(1);
}
Establece las variables de entorno horarios TZ; asigna valores a las
variables globales timezone, daylight y tzname. Funciones relacionadas: mkdir, rmdir, setdisk, system.
tzset();
printf(“Luz de verano = %d\n”, daylight); findfirst #include <dir.h>
printf(“zona horario = %ld\n”, timezone);
int findfirst(const char *camino, struct ffblk *ffblk, int atrib);
Funciones relacionadas: asctime, ftime, gmtime, localtime,
time.
Busca en un directorio de disco hasta encontrar el primer archivo cuyo
nombre y atributos se corresponden con los valores especificados. El for-
mato de la estructura ffblk es:
unixtodos #include <time.h>
struct ffblk {
void unixtodos(long time, struct date *f, struct time *h); char ff_reserved[21]; // reservada por DOS
apenf.qxd 26/11/99 14:17 Página 631

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 631

char ff_atrib; // encontrado atributo


fnsplit #include <dir.h>
int ff_ftime; // hora archivo
int ff_date; // fecha archivo
long ff_fsize; // tamaño archivo void fnsplit(const char *camino, char *u, char *dir,
char ff_name[13]; // encontrado nombre de archivo char *nombrearch, char *ext);
};
Separa un nombre de camino completo en sus componentes: letra de la
La variable attrib viene definida en el archivo de cabecera <dos.h> y unidad (u), camino del directorio, nombre del archivo y extensión del archi-
puede ser igual a uno de estos valores: vo (ext).
FA_RDONLY Archivo de sólo lectura. h = fnsplit(camino, unidad, dir, nomarch, ext);
FA_HIDDEN Archivo oculto.
FA_SYSTEM Archivo del sistema. Funciones relacionadas: fnmerge.
FA_LABEL Etiqueta de volumen.
FA_DIREC Directorio.
FA_ARCH Bit de archivo activado.
struct ffblk ffblk; getcurdir #include <dir.h>
int t;
t = findfirst(“*.*”, &ffblk,0); int getcurdir(int u, char *dir);
Funciones relacionadas: findnext.
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
findnext #include <dir.h>
caso de error devuelve –1.
int findnext(struct ffblk *ffblk);
getcurdir(3, cuentas);
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 Funciones relacionadas: getcwd, getdisk.
atributos son idénticos a los dados en la llamada a la función findfirst().
findnext(&filefinfo);
getcwd #include <dir.h>
Funciones relacionadas: findfirst.
char *getcwd(char *camino, int numcar);

fnmerge #include <dir.h> getcwd obtiene el nombre de camino completo del directorio de traba-
jo actual, incluyendo el nombre de la unidad. El argumento numcar indica
void fnmerge(char *camino, const char *u, const char *dir, a getcwd el máximo número de caracteres que el buffer camino puede con-
const *nombrearch, const char *ext); tener. 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 eje-
Crea un nombre de camino completo compuesto de una letra de la uni- cución, puede utilizar el nombre guardado para restaurar el directorio de tra-
dad (u), camino del directorio (dir), nombre de archivo (nombrearch) y bajo actual antes de terminar.
extensión del archivo (ext).
fnmerge(camino, “c:”, \\aux\\”,”demo”,”.dat”); getcwd(cuentas, 80)

Funciones relacionadas: fnsplit. Funciones relacionadas: chdir.


apenf.qxd 26/11/99 14:17 Página 632

632 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

getdisk #include <dir.h> Funciones relacionadas: chdir, rmdir.

int getdisk(void);
mktemp #include <dir.h>
La función getdisk obtiene el valor entero que representa la unidad
actual (0, unidad A; 1, unidad B...) char *mktemp(char *plantilla);

int unidad; Crea un nombre de archivo a partir de una plantilla. Devuelve un pun-
clscr(); tero al nombre del archivo si tiene éxito y nulo en caso de error.
unidad = getdisk();
mktemp(nombre);
Funciones relacionadas: setdisk.

mdir #include <dir.h> searchpath #include <dir.h>

int rmdir(const char *camino); char searchpath(const char *nombre);

Elimina el directorio escrito por la variable camino, siempre que el Busca un archivo específico en una lista de directorios, incluyendo el
directorio esté vacío, no sea el directorio raíz y no sea el directorio de tra- directorio de trabajo actual y los definidos en la variable de entorno PATH.
bajo rmdir(); devuelve 0 si la operación de borrado tiene éxito; si se pro- Si el archivo se encuentra, se devuelve un puntero al nombre del camino del
duce un error, el valor devuelto es –1 y la variable global errno se fija a uno archivo; en caso contrario, se devuelve NULL.
de los siguientes valores:
buffer = searchpath(“BC.EXE”);
EACCES Permiso denegado.
ENOENT Camino archivo no encontrado. Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la
variable de entorno PATH.
Esta función es similar a RMDIR o RD de MS-DOS.
buffer = searchpath(“autoexec.bat”);
rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS

Funciones relacionadas: chdir, mkdir. Funciones relacionadas: getenv, putenv.

mkdir #include <dir.h> setdisk #include <dir.h>

int mkdir(const char *camino); int setdisk(int unidad);

Crea un directorio con un nombre de camino especificado. Funciona Cambia a una nueva unidad por omisión. El valor de la unidad (unidad)
igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha es un entero.
creado con éxito o –1 si se produce un error; en este caso, la variable global Unidad A
errno toma el valor EACCES (permiso denegado) o ENOENT (nombre de
B:
camino no válido). C:
EACCES Permiso denegado. D:
...
ENOENT Camino no encontrado.
nuevaunidad = setdisk(3); / nueva unidad actual es C:
resultado = mkdir(“PRUEBAS”);
// crea el directorio PRUEBAS Funciones relacionadas: getdisk
apenf.qxd 26/11/99 14:17 Página 633

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 633

F.8. FUNCIONES DE CONTROL DE PROCESOS atexit #include <stdlib.h>

Un proceso es un programa ejecutable en memoria y su entorno asociado. int atexit(void(*func)(void));


Cada vez que se ejecuta un programa se crea un proceso.
En resumen, un proceso es un programa que se está ejecutando por el Procesa la función especificada al salir.
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. atexit(segundo);
Siempre que se ejecuta un programa al nivel del sistema operativo se arran-
ca un proceso. Funciones relacionadas: abort, exit, _exit.
Las funciones de control de proceso permiten arrancar, detener y ges-
tionar 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 exec(familia) #include <process.h>
de cabecera que contienen funciones de control de proceso y del entorno son
locale.h, signal.h, setjmp.h y stdlib.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);

abort #include <process.h> int execlpe(char *camino, char *arg0,...argn, NULL, char **env);
#include <stdlib.h> int execv(char *camino, char argv[]);

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


int execvp(char *camino, char *argv[]);
Termina la ejecución del programa actual y devuelve un código de
error (3). int execvpe(char *camino, char *argv[], char **env);

if (argc 1) { Cargan y ejecutan un proceso hijo en la memoria actualmente ocupada


printf(“Faltan argumentos!\n”) por su código del programa. Las funciones exec crean un proceso hijo que
abort() carga y ejecuta el programa especificado por el argumento camino.
}
execlo(“hijo.exe”, hijo.exe”, “Uno, “Dos”, NULL);
Funciones relacionadas : exit, _exit, raise, signal, spaw.
execv(“hijo.exe”, argv);

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


assert #include <assert.h>

exit #include <stdlib.h>


void assert(int expresión);
void exit(int estado);
Imprime un mensaje de error e interrumpe el programa si expresión es
falsa (0).
Termina un programa. Antes de terminar, se cierran todos los archivos,
assert(string != NULL; se escribe la salida a través del buffer y se llama a cualquier función exit
assert(*string != ´\0´); registrada. estado representa el estado de salida del programa; 0, salida
assert(strlen(string) < 2); normal; distinto de cero, indica un error.

Funciones relacionadas: abort, raise, signal. exit(0);


apenf.qxd 26/11/99 14:17 Página 634

634 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Funciones relacionadas: abort, atexit, ´exit, exit, ´fpreset, Obtiene información detallada sobre formatos monetarios y numéricos
spawn, system. de diferentes países.

p_lconv = localeconv();
_exit #include <stdlib.h>
Funciones relacionadas: setlocale.
void _exit(int estado);

Termina inmediatamente el proceso actual sin hacer otras operaciones longjmp #include <setjmp.h>
auxiliares (como cierre de archivos).
void longjmp(jmp_buf env, int valor);
_exit(0)
Restaura el estado de la pila y la ejecución local anteriormente grabada
Funciones relacionadas: exit. en env por setjmp.

longjmp(plaza, 3);
getenv #include <stdlib.h>
Funciones relacionadas: setjmp.
char *getenv(const char *nomvar);
perror #include <stdio.h>
Obtiene la definición de una variable de la tabla de entorno del proce-
so. Utiliza la variable global environ para localizar la lista de las variables
void perror(const char *cadena);
de entorno y, a continuación, busca una entrada en la lista correspondiente
a nomvar. Imprime un mensaje de error del sistema en el flujo stderr. El argu-
mento cadena se imprime primero, seguido por dos puntos; a continuación,
varlib = getenv(“LIB”); el mensaje de error correspondiente al valor actual de la variable global
errno y, finalmente, un carácter de nueva línea. Si cadena es un puntero
Funciones relacionadas: putenv. nulo o un puntero a una cadena nula, perror imprime sólo el mensaje de
error del sistema.
getpid #include <process.h> perror(“Error de cierre de archivos”);

unsigned getpid(void) Funciones relacionadas: _strerror, strerror.


Obtiene el ID de proceso de un programa. Está disponible en sistemas
UNIX. putenv #include <stdlib.h>

printf(“PID:%X\n”,getpid()); int putenv(const char *cadena);

Funciones relacionadas: getpsp. Crea nuevas variables de entorno o modifica los valores de las variables
de entorno existentes.

localeconv #include <locale.h> if(putenv(argv[1] == -1)

struct lconv *localeconv(void); Funciones relacionadas: getenv.


apenf.qxd 26/11/99 14:17 Página 635

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 635

int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL,


raise #include <signal.h>
char **envp[]);
int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL);
int raise(int señal); int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL,
char **envp[]);
Envía una señal al programa en ejecución. Crea una condición de int spawnv(int modo, char *camino, char *argv[]);
excepción correspondiente al número señal. Existen diferentes constantes, int spawnve(int modo, char *camino, char /argv[], char *envp[]);
por ejemplo, SIGABRT (terminación anormal). int spawnvp(int modo, char *camino, char *argv[]);
int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);
printf(“prueba de raise\n”);
raise(SIGABRT); La familia de funciones spawn crea y ejecuta un nuevo proceso hijo.
Debe haber memoria suficiente para cargar y ejecutar el proceso hijo.
Funciones relacionadas: abort, signal.
spawnlpe(P_WAIT, “hijo.exe”, “hijo.exe”, “spawnlpe”, buf,
NULL, env);
setjmp #include <setjmp.h>
Funciones relacionadas: exec.
int setjmp(jmp_buf env);

Guarda el estado actual del programa (el entorno de la pila) antes de lla-
mar a otra función. Este entorno puede ser restaurado por una llamada a F.9. FUNCIONES DE CONVERSIÓN DE DATOS
longjmp, realizando el efecto de un goto no local.
Las funciones de conversión de tipos de datos sirven para crear un puente de
if(setjmp(env) != 0) printf(“valor de longjmp\n”); 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 relacionadas: longjmp. funciones de conversión son ideales para convertir argumentos de líneas de
órdenes de su representación de cadena al formato interno.

signal #include <signal.h>


atof() #include <math.h>
void (*signal(int sig, void (*func) (int))) (int); #include <stdlib.h>

Establece tratamiento de señales de interrupción. La función signal per- double atof(const char *cadena);
mite a un proceso elegir uno de los diferentes modos de manipular una señal
de interrupción del sistema operativo. La función atof() convierte el argumento cadena en un valor de doble
precisión. La cadena debe tener el siguiente formato:
signal(SIGINT, SIG_IGN);
[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]
Funciones relacionadas: abort, _control87, exit, longjmp, raise,
setjmp. opcional e/E

blancos o dígitos decimales


spawn (funciones) #include <stdio.h> tabulaciones
#include <process.h>
La conversión termina cuando aparece el primer carácter no reconoci-
int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL); ble o cuando se encuentra un carácter nulo (´\0´).
apenf.qxd 26/11/99 14:17 Página 636

636 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

double x; La conversión de caracteres de la cadena hasta que se encuentre el pri-


char *cad_dbl = “200-85”; mer carácter no reconocible o el carácter nulo (‘\0’).
...
x = atof(cad_dbl); // convierte la cadena “200.85” long int i;
a real char cad_ent = “9876543”;
...
Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf, i = atol(cad_ent); // convierte cadena “9876543” a entero
strtod. // largo.

Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod,


atoi #include <stdlib.h> strtol, strtoul, ultoa.

int atoi (const char *cadena)

ecvt #include <stdlib.h>


La función atoi() convierte el argumento cadena en un valor entero.
La cadena debe tener el siguiente formato:
char *ecvt(double valor, int n, int *dec, int *signo);
[espacio en blanco][signo][ddd]
La función ecvt() convierte un argumento de valor doble precisión en
opcional una cadena con n dígitos. Si valor tiene más de n dígitos, los dígitos infe-
riores se truncan. dec es un puntero a un entero en donde se devuelve la
espacio o tabulación dígitos decimales posición del punto decimal; signo es un puntero a un entero donde se
devuelve el signo (cero, positivo; en los restantes casos, negativo).
La conversión termina cuando se encuentra un carácter no reconocible
p_buffer = ecvt(valor, exactitud, &dec, &signo);
(carácter nulo, ‘\0’, punto decimal o una letra). Si no puede convertir la
cadena devuelve nulo.
Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa,
ltoa, ultoa.
int i;
char *cad_ent =123;
...
i = atoi(cad_ent);// convierte la cadena “123” al entero 123 fcvt #include <stdlib.h>

Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa. char *fcvt(double valor, int n, int *dec, int *signo);

Al igual que la función ecvt, fcvt convierte el argumento valor de


atol #include <stdlib.h> doble precisión en una cadena de n dígitos. Si el número de dígitos de valor
excede a n, el exceso de dígitos se trunca. Si hay menos dígitos que n la
long atol(const char *cadena); cadena se rellena con ceros. fcvt se diferencia de ecvt en el modo de tra-
tar los dígitos significativos. ecvt() busca un número total de dígitos,
Convierte el argumento cadena en un valor entero largo. La cadena debe
mientras que fcvt() busca el número de dígitos a la derecha del puntero
tener el formato:
decimal.
[espacio en blanco][signo][ddd]
cadena = fcvt(valor, exactitud, %oposición_d, &signo);
opcional
Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,
blancos y tabulaciones dígitos decimales sprintf, ultoa.
apenf.qxd 26/11/99 14:17 Página 637

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 637

gcvt #include <stdlib.h> strtod #include stdlib.h>

char *gcvt(double valor, int ndig, char, *buf); double strtod(const char *cad, char **p);

La función gcvt() convierte el argumento valor de doble precisión en La función strtod() convierte la cadena cad en un valor de doble
una cadena de caracteres que se almacena en el buffer cuya dirección se da precisión. La cadena debe tener el formato
en el argumento buf. Se debe asignar bastante espacio en el buffer para con-
[blanco][signo][ddd][.][exponente][signo][ddd]
tener todos los dígitos de la cadena convertida y el carácter nulo de termi-
nación (‘\0’).
+, - d, D, e, E
gcvt(valor, digitos, cadena);
blanco/ dígitos decimales
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf, tabulación
sprintf, ultoa.
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 flo-
itoa #include stdlib.h> tante double.
#include <stdio.h>
char *itoa(int valor, char *cad, int base);
#include <stdlib.h>
La función itoa() convierte el argumento entero valor en una cadena main()
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 double x;
char *num_flt = “843899.567”:
caracteres, itoa() devuelve un puntero a la cadena cad.
char *p;
itoa(32, buffer, 16); // buffer contendrá “20”, ya que 32 entero x = strtod(num_flt, &p);
// equivale a 20 en hexadecimal printf(“x = %f\n”,x);
}
Funciones relacionadas: atoi, atol, itoa, ultoa.
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.

ltoa #include <stdlib.h>


strtol #include <stdlib.h>
char *ltoa(long valor, char * cad, int base);
long strtol(const char *cad, char **p, int b);
La función ltoa() convierte el argumento entero largo valor en una
cadena de caracteres que utiliza el argumento base como base de un siste- La función strtol() convierte una cadena cad en un valor entero largo.
ma de numeración. Como un entero largo ocupa 32 bits en base 2, la cade- La cadena (puede contener hasta 33 caracteres) debe tener el formato:
na puede ocupar 33 bytes con el carácter nulo de terminación. Debe haber
bastante espacio para contener 33 bytes. ltoa() devuelve un puntero a cad. [espacio en blanco][signo][0][x|X][ddd]
long valor = 99288377L
ltoa(valor, cadena, 30); +, - dígitos decimales
hexadecimal
Funciones relacionadas: atoi, atol, itoa, ultoa. blancos y tabulaciones octal
apenf.qxd 26/11/99 14:17 Página 638

638 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

La conversión se termina con el primer carácter no reconocible. Si se ultoa #include <stdlib.h>


produce un error de desbordamiento (positivo o negativo) la variable errno
se establece al valor de la macro ERANGE. char *ultoa(unsigned long valor, char *cad, int base);
Aplicación. Convertir la cadena “9876” en valor entero.
La función ultoa() toma valor en base b (entre 2 y 36) y lo convierte
#include <stdio.h> en una cadena. Devuelve el puntero al principio de cad. No devuelve códi-
#include <stdlib.h> go de error. cad puede contener hasta 33 caracteres, excluyendo el carácter
de terminación nulo (´\0´).
main()
{ ultoa(valor, buffer, base);
int base = 10;
long int i;
Funciones relacionadas: itoa, ltoa.
char *cad_ent = “9876”;
char *ptrcad;
i = strtol(cad_ent, &ptrcad, base);
printf(“i = %ld\n”, i); F.10. FUNCIONES DE ENTRADA/SALIDA
}
Las funciones de E/S (Entrada/Salida, I/O, Input/Output) permiten leer y
Funciones relacionadas: atoi, atof, atol, ltoa, strtoul. 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:
strtoul #include <stdlib.h>
1. Secuencias o flujos (stream).
unsigned long strtoul(const char *cad, char **p, int base); 2. Bajo nivel.
3. Consola y puertos.
Convierte una cadena de caracteres a un entero largo sin signo en la
base dada. La cadena debe tener el formato: Funciones de flujos (stream)

[espacio en blanco][0][x|X][ddd] Las funciones de E/S tratan los datos como una secuencia o flujo de carac-
teres individuales. La elección adecuada de las funciones disponibles per-
mite procesar datos en tamaños y formatos diferentes, desde caracteres inde-
dígitos decimales pendientes a estructuras de datos complejos. La E/S por secuencia, o flujo,
octal también proporciona acciones de taponamiento (buffering) que mejoran sig-
blanco o tabulaciones hexadecimal nificativamente el rendimiento. Para utilizar los flujos, generalmente se
debe incluir el archivo stdio.h.
Si la base b es cero, strtoul utiliza el primer carácter de la cadena para
determinar la base del valor. clearerr #include <stdio.h>
La cadena cad puede contener hasta 33 caracteres, excluyendo el carác-
ter de terminación nulo (´\0,). Si se produce un error de desbordamiento, void clearerr(FILE *f);
la variable errno se pone al valor de ERANTE.
Reinicializa el indicador de error de un flujo f.
i = strtoul(cad_ent, &ptrfin, base);
clearerr(fichen);

Funciones relacionadas: atol, ultoa, strtol. Funciones relacionadas: eof, feof, ferror, perror.
apenf.qxd 26/11/99 14:17 Página 639

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 639

fclose, fcloseall #include <stdio.h> fflush #include <stdio.h>

int fclose(FILE *f); int fflush(FILE *f);


int fcloseall(void);
Limpia (vacía) un flujo. Los buffers se limpian automáticamente cuan-
Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall) do están llenos, cuando se cierra el flujo, o cuando un programa termina nor-
excepto stdin, stdout y stderr. Se devuelve el número de flujos cerrados malmente sin cerrar el flujo.
y EOF si se produce un error.
fflush(fp);
fcloseall();
Funciones relacionadas: fclose, flshall, fopen.
Funciones relacionadas: close, fdopen, fopen.

fgetc #include <stdio.h>


fdopen #include <stdio.h>
int fgetc(FILE * f);
FILE *fdopen(int handle, char *modo);

Abre un flujo utilizando un handle (entero devuelto por las rutinas de Lee un carácter de la posición actual del archivo y, a continuación,
E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una incrementa esta posición.
estructura de datos FILE con el archivo especificado por handle.
c = fgetc(fp)
p_datos = fdopen(handle, “rb”);
Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc,
Funciones relacionadas: fclose, fopen, fropen, open. putchar.

feof #include <stdio.h> fgetchar #include <stdio.h>

int feof(FILE *flujo); #int fgetchar(void);

Comprueba el final de archivo de un flujo. Lee un carácter del archivo stdin, normalmente el teclado.
feof(fichen);
c = fgetchar();
Funciones relacionadas: clearerr, fclose, rewind.
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.

ferror #include <stdio.h>


fgetpos #include <stdio.h>
int ferror(FILE *f);
int fgetpos(FILE *flujo, fpos_t *p);
Verifica si se ha producido un error en un flujo f.
Obtiene y graba la posición actual del archivo. fos_t es un tipo defini-
ferror(fichen); do en stdio.h.

Funciones relacionadas: clarerr, eof, feof, fopen, perror. fgetpos(fp, &pos_archivo);


apenf.qxd 26/11/99 14:17 Página 640

640 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

if ((corriente2 = fopen(“datos”, “W+”)) == NULL


fgets #include <stdio.h>
printf(“el archivo..no se ha abierto \n”);
char *fgets(char *cad, int n, FILE *f);
Funciones relacionadas: fclose, fcloseall, fdopen, ferror,
fileno, freopen, open, setmode.
Lee una cadena de un flujo (hasta que se encuentra \n, o el número
máximo de caracteres especificados).

fgets(caddemo,80, fp); flushall #include stdio.h>

Funciones relacionadas: fputs, gets, puts. int flushall(void);

Vacía (limpia) todos los buffers asociados con los archivos abiertos.
fileno #include <stdio.h>
numvaciados = flushall();
int fileno(FILE *f);
Funciones relacionadas: fclose, fflush.
Obtiene el mando o manejador (handle) del archivo asociado con un
flujo.
fprintf #include <stdio.h>
fileno(stdin);
int fprintf(FILE *f, const char *formato[arg,...]);
Funciones relacionadas: fdopen, fopen.
Imprime datos con formato en un flujo.

fopen #include <stdio.h> fprintf(f1,”El resultado es %f\n”,result);

FILE *fopen(const char *f, const char *modo); Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
Abre un archivo f. La cadena de caracteres modo especifica el tipo de
acceso.
fputc #include <stdio.h>
Modo Acción
int fputc(int c, FILE *f);
“r” Abre para lectura.
“w” Abre un archivo vacío para escritura. Escribe un carácter c en el flujo abierto para salida con buffer.
“a” Abre para escritura al final del archivo (añadir).
“r+” Abre para lectura/escritura. fputc(*(p++), stdout);
“w+” Abre un archivo vacío para lectura/escritura.
“a+” Abre para lectura y añadir. Funciones relacionadas: fgetc, fgetchar, fputchar, getc, get-
“rb” Abre un archivo binario para lectura. char, putc.
“wb” Crea un archivo binario para escritura.
“ab” Abre un archivo binario para añadir.
“rb” Abre un archivo binario para lectura/escritura.
fputchar #include <stdio.h>
“wb” Crea un archivo binario para la lectura/escritura.
“ab” Abre o crea un archivo binario para lectura/escritura.
int fputchar(int c);
apenf.qxd 26/11/99 14:17 Página 641

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 641

Escribe el carácter c en stdout. Lee datos con formato de un flujo.

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

Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar. Funciones relacionadas: csanf, fprintf, scanf, sscanf.

fputs #include <stdio.h> fseek #include <stdio.h>

int fputs(const char *cad, FILE *f); int fseek(FILE *f, long desp, int org);

Escribe una letra cad en un flujo f. Devuelve el último carácter impre- Mueve el puntero del archivo asociado con f a una nueva posición que
so, si hay error devuelve EOF. está desplazada desp bytes de org.

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

Funciones relacionadas fgets, gets, puts. SEEK_SET Principio de archivo.


SEEK_CUR Posición actual puntero archivo.
SEK_END Final de archivo.
fread #include <stdio.h>
fseek(f1,OL,SEEK_SET); // ir al principio
size_t fread(void *p, size_t t, size_t n, FILE *f);
Funciones relacionadas: ftell, rewind, fopen.
Lee n registros de t bytes en la memoria apuntada por p desde el flujo f.

fread(buf, strlen(msg)+1, 1, flujo); fsetpos #include <stdio.h>

Funciones relacionadas: fwrite, read. int fsetpos(FILE *f, const fpos_t *p);

Establece la posición del puntero del archivo al lugar especificado por


freopen #include <stdio.h> el objeto apuntado por p.
fsetpos(fp, &posarch);
FILE *freopen(const char *f, const char *m, FILE *flujo);
Funciones relacionadas: getpos.
Cierra el archivo asociado con flujo y reasigna flujo al archivo espe-
cificado por f. Los modos (m) utilizados son los mismos de fopen.
ftell #include <stdio.h>
freopen(“salida.txt”, “w”, stdout);
long int ftell(FILE *f);
Funciones relacionadas: fclose, fopen.
Obtiene la posición actual (puntero) del archivo asociado con el flujo f.
fscanf #include <stdio.h> ftell(fichen);

int fscanf(FILE *f, const char *formato [, dirección,...]); Funciones relacionadas: fgetpos, fssek, tell.
apenf.qxd 26/11/99 14:17 Página 642

642 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

fwrite #include <stdio.h> Devuelve el siguiente carácter de stdin. Si se alcanza el final de archi-
vo, se devuelve EOF.
size_t fwrite(const void *p, size_t l, size_t n, FILE *f);
int c;
Escribe n elementos (registros) de longitud l desde la memoria apunta- while((c = getchar())!= ´\n´)
da por p al archivo f. Devuelve el número de caracteres realmente escritos printf(“%c”, c);
que, si la función tiene éxito, es igual al número indicado.
Funciones relacionadas: fgetc, fgetchar, getch, getche, putc,
num = fwrite(lista, sizeof(char),25,flujo); putchar, ungetc.

Funciones relacionadas: fread, fscanf, getc, fgetc.


getche #include <stdio.h>

getc #include <stdio.h>


int getche(void);

int getc(FILE *f);


Lee un carácter del teclado haciendo eco del carácter en la pantalla.
Devuelve el siguiente carácter de un flujo de entrada dado e incremen-
resp= getche();
ta la posición actual del puntero del archivo. Si se alcanza el final de archi-
vo, se devuelve EOF.
Funciones relacionadas: cgets, getch, getchar, ungetch.
whilec(c = getc(fx)!= EOF) {
printf(“%c”, c);
}
gets #include <stdio.h>

Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc, char *gets(char *cad);
putchar, fopen.
Lee una línea desde el archivo de entrada estándar stdin, por omisión
es el teclado y lo guarda en cad.
getch #include <stdio.h>
gets(nombre);
int getch(void)
Funciones relacionadas: fgets, fputs, puts.
Lee un carácter del teclado sin hacer eco en la pantalla.
do {
car = getch();
char = toupper(car); getw #include <sdio.h>
} while(car != ´S´);
int getw(FILE *f);
Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.
Lee un entero (o una palabra de dos bytes) de un flujo f.

getchar #include <stdio.h> suma = getw(fx) + suma;

int getchar(void); Funciones relacionadas: fread, putw.


apenf.qxd 26/11/99 14:17 Página 643

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 643

printf #include <stdio.h> puts #include <stdio.h>

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

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


Escribe cadenas de caracteres y valores de variables, con formato, en el
archivo de salida estándar stdout (por omisión, la pantalla). puts(“Desea continuar(s/n?”);

Código Formato Funciones relacionadas: fgets, fputs, gets.


%c Carácter.
%d Entero decimal. putw #include <stdio.h>
%e Real (double o float), notación científica.
%f Coma flotante. int putw(int i, FILE *f);
%s Cadena de caracteres. Escribe un entero en un flujo f.
%x Hexadecimal sin signo.
putw(100, fx);
printf(“producto %d y %d es %d\n”,x,y, x*y); Funciones relacionadas: getw, printf.
Funciones relacionadas: fprintf, scanf, sprintf, viprintf,
vprintf, vsprintf. rewind #include <stdio.h>

void rewind(FILE *f);

putc, putchar #include <stdio.h> Reinicializa el puntero del archivo al principio de un flujo.

int putc(int c, FILE *f); rewind(fx);


int putchar(int c);
Funciones relacionadas: fseek.
Escribe un carácter en un flujo (putc) o en stdout (putchar).
scanf #include <stdio.h>
putc(´*´, demo);
int scanf(const char *formato[,dirección,...]);
Funciones relacionadas: fputc, fputchar, getc, getchar.
Lee datos con formato del flujo de entrada estándar.

Código Formato
putch #include <stdio.h>
%c Carácter.
%d Entero decimal.
int putch(int c);
%x Hexadecimal.
%i Entero decimal.
Escribe un carácter en la pantalla.
%f Número real.
%o Octal.
putch(´B´);
%p Puntero.
%s Cadena.
Funciones relacionadas: putc, putchar.
apenf.qxd 26/11/99 14:17 Página 644

644 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

scanf(“%d %f %c %s”, &i, &fp, &c, s); Esta función es idéntica a scanf, excepto que los datos son leídos del
array apuntado por b, en vez de stdin.
Funciones relacionadas: fscanf, printf, sscanf, vfprintf,
vprintf, vsprintf sscanf(buffer, “%,s%s”,uno,dos,tres);

Funciones relacionadas: cscanf, fscanf, scanf, vscanf.


setbuf #include <stdio.h>

void setbuf(FILE *f, char *buffer); tmpfile #include <stdio.h>

Asigna un buffer a un flujo. FILE *tmpfile(void);

setbuf(fx, buffer); Crea un archivo temporal y devuelve un puntero a ese flujo.

Funciones relacionadas: setvbuf. if((aux = tmpfile()) == NULL)...

Funciones relacionadas: tmpnam.


setvbuf #include <stdio.h>

int setvbuf(FILE *f, char *b, int t, size_t l); tmpnam #include <stdio.h>

Asigna el buffer b de tamaño l y el tipo t con el flujo (archivo) f. Los char *tmpnam(char *s);
valores correctos de t son: _IOBF, _IONBF e _IOLBF.
Genera un único nombre de archivo y lo guarda en el array apuntado por s.
setvbuf(demo, buffer, _IOFBF, 120);
tmpnam(prueba);
Funciones relacionadas: setbuf.
Funciones relacionadas: tmpfile.

sprintf #include <stdio.h>


ungetc #include <stdio.h>
int sprintf(char *b, const char *f[,arg,...]);
int ungetc(int c, FILE *f);
Escribe datos con formato en una cadena. Se diferencia de printf en
que la salida generada se sitúa en el array apuntado por b. Sitúa un carácter, excepto la constante EOF, en el buffer asociado con un
archivo abierto para entrada con buffer.
sprintf(cad, “&s %d %c”, “uno”,5,´7´);
ungetc(car, stdin);
Funciones relacionadas: sprintf, printf, vprintf, vfprintf,
vsprintf. Funciones relacionadas: getc.

sscanf #include <stdio.h> ungetch #include <stdio.h>

int sscanf(const char *b, const char *f[,dirección,...]); int ungetch(int ch);
apenf.qxd 26/11/99 14:17 Página 645

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 645

Empuja un carácter en la memoria intermedia del teclado. vsscanf #include <stdio.h>


#include <stdarg.h>
char ch;
ch = getch();
ungetch(ch); int vsscanf(const char *b, const char *f, lista_va
lista_arg);

vfprintf, #include <stdio.h> Funciona igual que sscanf, excepto que en vsscanf es utilizado un
vprintf, #include <stdarg.h> puntero a una lista de variables en lugar de a las propias variables.
vsprintf
vsscanf(buf_en, formato_p, arg_p);
int vfprintf(FILE *f, const char *f, lista_va lista_arg);
int vprintf(const char *f, lista_va lista_arg); Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.
int vsprintf(char *b, const char *f, lista_va lista_arg);

Escribe salida con formato utilizando un puntero a una lista de argu- Funciones de bajo nivel
mentos.
Las declaraciones de las funciones de bajo nivel se incluyen en los archivos
vprintf(formato, nota); de cabecera io.h, fcntl.h, sys|types.h y sys|sta.h. A diferencia de
las funciones stream, las funciones de bajo nivel no requieren el archivo de
Funciones relacionadas: fprintf, printf, sprintf, va_arg, inclusión stdio.h.
va_end, va_strat.

_close, close #include <io.h>


vfscanf #include <stdio.h>
#include <stdarg.h> int _close(int h);
int close(int h);
int vfscanf(FILE *F, const char *f, lista_va lista_arg);

Lee entrada con formato de un flujo, tal como scanf, excepto que vfs- Cierra el archivo especificado en h. Estas funciones se utilizan con
canf acepta un puntero a la lista de argumentos. _open y open.

vfscanf(demo, formato, arg); close(f1);

Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf. Funciones relacionadas: fclose, fopen, open.

vscanf #include <stdio.h> _creat #include <io.h>


creat #include <sys\stat.h>
int vscanf(const char *f, lista_va lista_arg); #include <dos.h>
Lee una entrada con formato de un flujo; similar a scanf, excepto que
vscanf acepta un puntero a la lista de argumentos. int creat(const char *cam, int modo);
int _creat(const char *cam, int atributo);
vscanf(formato, argumento);
Crea un nuevo archivo o abre y trunca un archivo existente. _creat()
Funciones relacionadas: fscanf, scanf, sscanf, fsca. actúa igual que creat(), excepto que utiliza un byte de atributo del DOS.
apenf.qxd 26/11/99 14:17 Página 646

646 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Modo Significado eof #include <io.h>


S_IWRITE Permiso de escritura. int eof(int d);
S_IREAD Permiso de lectura.
S_IREAD|S_IWRITE Permiso de lectura y escritura. Comprueba si el archivo especificado en el descriptor d es el final de
archivo (se devuelve 1 si se alcanza el final del archivo. 0 si no se alcanza
fh= creat(“datos”,S_IREAD|S_IWRITE); el final del archivo, –1 indica un error y errno toma valor EBADF: número
de archivo incorrecto).
Funciones relacionadas: chmod, close, open umask.
while(!eof(fx))

creatnew #include <io.h> Funciones relacionadas: feof, ferror, perror.


#include <dos.h>

int creatnew(const char *camino, int atributo); lseek #include <io.h>


#include <stdio.h>
Crea un archivo nuevo con los atributos especificados.
long lseek(int d, long desp, int origen);
h = creatnew(“F.FIL”,0);
La función lseek mueve el puntero asociado con el descriptor d a una
Funciones relacionadas: _creat, fopen, open. nueva posición que está emplazada desp bytes de origen.
pos = lseek(fh, OL, SEEK_CUR);

creattemp #include <io.h> Funciones relacionadas: fseek, tell.


#include <dos.h>

int creattemp(char *camino, int atributo); open #include <fcntl.h>


#include <io.h>
Crea un único archivo temporal con byte de atributo en el directorio #include <sys\stat.h>
escrito por camino.
int open(const char *f, int a[, unisgned m]);
if((h = creattemp(“nombre”,9))== -1
Abre el archivo especificado en f para lectura o escritura. El argumen-
Funciones relacionadas: tmpfile. to a indica el tipo de operación permitida y m el tipo de permiso.

Indicador
dup, dup2 #include <io.h> Significado
Lectura/escritura
int dup(int h); O_RDONLY Abrir para lectura.
int dup2(int h1, int h2); O_WRONLY Abrir para escritura.
O_RDWR Abrir para lectura y escritura.
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace O_NDELAY Pone el puntero del archivo al final del archivo.
de archivo (dup2). O_APPEND Se crea el archivo y se fijan atributos del archivo.
O_TRUNC Trunca el archivo a 0.
viejostdout = dup(STDOUT);
O_EXCL Se utiliza con O_CREAT.
dup2(fptr, STDOUT);
O_BINARY Abrir archivo en modo binario.
O_TEXT Abrir archivo en modo texto.
Funciones relacionadas: close, creat, open.
apenf.qxd 26/11/99 14:17 Página 647

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 647

open(“OPEN.OUT”, 0_WRONLY|O_CREAT, S_IREAD|IWRITE); Devuelve la posición actual del puntero del archivo especificado por d.
if((h = open(“open.tst”, O_CREAT))==1)...
posi = tell(desf);
Funciones relacionadas: access, chmod, close, creat, fopen.
Funciones relacionadas: ftell, lseek.

sopen #include <fcntl.h>


#include <io.h>
#include <share.h> write #include <io.h>
#include <sys/stat.h>
int write(int d, void *buffer, unsigned lon);
int sopen(char *f, int a, int s[, int m]);
Escribe datos en un archivo (lon bytes en el archivo asociado con d
Abre un archivo f con acceso a en modo compartido en un entorno de desde el buffer apuntado por buffer).
red y con el tipo s de compartición permitido en el archivo y modo m.
write(fx, grande, 60000);

Indicador Funciones relacionadas: creat, open, read, sopen.


Significado
Lectura/escritura

O_RDONLY Abrir para lectura. Funciones de consola y puertos de E/S


O_WRONLY Abrir para escritura.
O_RDWR Abrir para lectura y escritura. Las funciones de E/S sirven para interactuar con el teclado y la pantalla.
S_IWRITE Acceso de escritura. Estas funciones se declaran en el archivo de cabecera conio.h.
S_IREAD Acceso de lectura.
S_IWRITE|S_IREAD Acceso de lectura y escritura.

cgets #include <conio.h>


df = sopen(“C:||autoexec.bat”, O_RDONLY, SH_DENYRW, S_IREAD);
char *cgets(char *cadena);
Funciones relacionadas: close, fopen.
Lee una cadena de caracteres directamente de la consola, y almacena la
cadena y su longitud en la posición apuntada por cadena.
read #include <io.h>
entrada = cgets(cadena);
int read (int d, void * buffer, unsigned lon);
Funciones relacionadas: cputs, getch, getche.
Lee lon bytes del archivo asociado con d en el buffer apuntado por
buffer.

read(fx, buffer, 100); cprintf #include <conio.h>

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


tell #include <io.h>
Escribe salida con formato directamente en la consola. Observe que
long tell(int d); cprintf no traduce el carácter (\n) a una combinación (CR-LF), en su lugar,
apenf.qxd 26/11/99 14:17 Página 648

648 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

\n se interpreta como avance de línea (LF) y \r se debe utilizar para indicar getpass #include <conio.h>
un retorno de carro (CR).
char *getpass(const char *indicador);
cprintf(“Cubo de %2d es %rd\r\n”,i, i * i * i);
Lee una palabra de paso por consola, que no se visualiza en pantalla
Funciones relacionadas: printf. (menos de ocho caracteres de longitud).

palabrapaso = getpass(“Introduzca clave”);


cputs #include <conio.h>
Funciones relacionadas: getch
int cputs(const char *cad);

Escribe una cadena en la pantalla. No se envía ningún carácter de nueva inport, inportb #include <dos.h>
línea después de la cadena.
int inport(int puerto);
cuts(“Está usted seguro(s/n)?”); unsigned char inportb(int puerto);

Funciones relacionadas cprintf. Lee una palabra de 16 bits (inport) o un byte (inportb) de un puerto
de E/S especificado por puerto.
La función inport es útil para leer dos puertos adyacentes a la vez, e
inportb para controlar dispositivos de entrada/salida.
cscanf #include <conio.h>
palabra = inport(PORT_8259_20);
int cscanf(char *formato [,dirección,...]); P21 = inportb(PORT_8259_21);

Lee caracteres con formato directamente desde la consola en la posición Funciones relacionadas: outport, poutportb.
dada por dirección.

cscanf(“%d%d%d, &dia, &mes, &hora); kbhit #include <conio.h>

Funciones relacionadas: fscanf, scanf, sscanf. int kbhit(void);

Comprueba si se ha pulsado recientemente una tecla.


get, getche #include <conio.h> // visualizar hasta que pulsa una tecla
while(!kbhit())
int getch(void); cputs(“Pulse una tecla”);
int getche(void);
Funciones relacionadas: getch, getche.
Lee un carácter de la consola sin eco (getch) o con eco (getche).

printf(«Pulse cualquier tecla para salir»); outport, outportb #include <conio.h>


getch();
void outport(int puerto, int palabra);
Funciones relacionadas: cgets, getchar, ungetch. void outportb(int puerto, unsigned char byte);
apenf.qxd 26/11/99 14:17 Página 649

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 649

Escribe una palabra de 16 bits (outport) un byte (outportb) en un Verifica si existe un archivo y, en caso afirmativo, los permisos de acce-
puerto de E/S. so al archivo.

outport(23,0); // 23 fuera del puerto Modo Significado


outport(´A´, 0) // A fuera de puerto
00 Se verifica existencia del archivo.
Funciones relacionadas: inp, inport, inportb, inpw. 01 Ejecutar.
02 Verifica permiso de escritura.
04 Verifica permiso de lectura.
putch #include <conio.h> 06 Verifica permiso de lectura y escritura.

int putch(int c);


return(access(nombre, 4)==-1)
Escribe un carácter en la consola (sin acción del buffer).
Funciones relacionadas: chmod, fstat, stat.
putch(car); putch(´\n´); putch(´x´);

Funciones relacionadas: getch, getche.


chmod #include <stdio.h>
#include <sys\stat.h>
ungetch #include <conio.h>
int chmod(const char *camino, int pmodo);
int ungetch(int c);
Cambia los permisos de lectura/escritura de un archivo.
Sitúa un carácter en el buffer del teclado de modo que es el siguiente
carácter leído en la consola. r = chmod(“prueba.tst”, S_IREAD);

if(c =!EOF) ungetch(c); Funciones relacionadas: access, fstat, stat.


ungetch(car);
pmodo Permiso de acceso
Funciones relacionadas: getch, getche, ungetc.
S_IWRITE Escritura.
S_IREAD Lectura.
S_IREAD|S_IWRITE Lectura/Escritura.
F.11. FUNCIONES DE GESTIÓN DE ARCHIVOS
El sistema de archivos es un componente clave del/de la PC. Todas las apli-
caciones y datos residen en archivos. Las funciones de gestión de archivos chsize #include <io.h>
permiten establecer y verificar permisos de acceso a archivos. La mayoría
de las funciones están en el archivo de cabecera io.h, y las restantes en int chsize(int manejador, long longitud);
sys|stat.h, dir.h y stdio.h.
Cambia el tamaño del archivo.

access #include <io.h> chsize(fh, 5);

int access(const char *nomarch, int modo); Funciones relacionadas: access, chmod, fstat, stat.
apenf.qxd 26/11/99 14:17 Página 650

650 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

filelength #include <io.h> Devuelve información sobre el archivo especificado en la estructura de


tipo stat apuntada por buffer. La estructura stat es:
long filelenght(int manejador);
struct stat {
short st_dev; // unidad o dispositivo
Obtiene la longitud de un archivo en bytes. short st_ino; // número inodo (UNIX)
short st_mode // modo archivo
filelength(fh); short st_nlink; // número enlaces (DOS,1)
int st_uid; // id de usuario (UNIX)
Funciones relacionadas: fileno, filestat, stat. int st_gid; // id de grupo (sólo UNIX)
int st_rdev; // dispositivo UNIX
long st_size; // tamaño archivo en bytes
long st_atime; // hora último acceso
fnmerge #include <dir.h> long st_mtime; // hora última (UNIX)
long st_ctime; // hora creación
};
void fnmerge(char *camino, const char *unidad,
const char *dir, const char *nombref, const char *ext); fstat(fich, &info);

Crea un nombre de camino completo (letra, unidad, camino directorio, Funciones relacionadas: access, chmod, stat.
nombre de archivo y extensión del archivo). En Microsoft, la función equi-
valente es _makepath.

fnmerge(camino,”C:”,\\aux,”resultado”,”.dat”);
isatty #include <io.h>
// nombre de camino”C:\aux\resultado.dat”
int isatty(int h);
Funciones relacionadas: fnsplit.
Determina si es un dispositivo orientado a carácter (terminal, consola,
impresora o puerto serie).
fnsplit #include <dir.h>
if(isatty(fileno(stdout)))
int fnsplit(const char *camino, char *unidad, puts(“es consola”);
char *dir, char *fnombre, char *ext);

Separa un nombre de camino completo en sus componentes: letra, uni-


dad, camino, nombre y extensión del archivo. lock #include <io.h>

f = fnsplit(c, unidad, dir, arch, ext); int lock(int h, long d, long n);

Funciones relacionadas: fnmerge. Bloquea un número de bytes n del archivo h (manejador) con desplaza-
miento se utiliza para compartición de archivos (orden SHARE de MS-
DOS). En Visual C++, la función equivalente es locking.

fstat #include <sys\stat.h> res lock(h, 0L,256); bloque de 256 bytes

int fstat(int h, struct stat *buffer); Funciones relacionadas: sopen, unlock.


apenf.qxd 26/11/99 14:17 Página 651

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 651

modo 0_BINARY(binario) 0_TEXT(texto)


mktemp #include <dir.h>
setmode(fileno(stdin), 0_BINARY);
// modo binario
char * mktemp(char *plantilla);

Crea un único nombre de archivo modificando una plantilla dada como Funciones relacionadas: fopen, open.
argumento, plantilla toma la forma basexxxxxx, donde base es el nom-
bre que se proporciona y x los caracteres a modificar.
stat #include <sys\stat.h>
char modelo = “tcbxxxxxx”;
int stat(char *f, struct stat *buffer);
mktemp(modelo);
Obtiene información sobre el estado de un archivo existente f.
Funciones relacionadas: tmpfile, tmpnam.
resultado = stat(“stat.c”,&buf);

remove #include <stdio.h> Funciones relacionadas: access, chmod, fstat.

int remove(const char *camino);


umask #include <io.h>
Borra el archivo especificado en camino.
unsigned umask(unsigned Pmodo);
remove(“C:\\ux\\demo”); // borra demo
Establece la máscara de permisos de lectura/escritura usados por open
Funciones relacionadas: unlink. y create.

Pmodo S_IREAD (sólo lectura)


S_IWRITE (sólo escritura)
rename #include <stdio.h> S_IREAD|S_IWRITE (lectura/escritura)
viejamascara = umask(S_IWRITE);
int rename(const char *vn, const char *nn);
Funciones relacionadas: chmod, creat, mkdir, open, sopen.
Renombre el archivo vn a nn.

int resultado; unlink #include <dos.h>


resultado = rename(viejo, nuevo); #include <io.h>
#include <stdio.h>
Funciones relacionadas: creat, fopen, open.
int unlink(const char *camino);

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


setmode #include <io.h>
#include <fcntl.h> result = unlink (“demo.jnk”);
if (result==0)
int setmode(int h, int modo); printf (“unlink tuvo éxito”);

Permite cambiar el modo del archivo abierto entre texto y binario. Funciones relacionadas: remove.
apenf.qxd 26/11/99 14:17 Página 652

652 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

unlock #include <conio.h> Las funciones complejas son propias de Borland C++ y no son expor-
tables.
int unlock(int h, long o, long l);
Clase bcd
Desbloquea una sección del archivo h que ha sido bloqueada con lock.
La clase bcd permite manipular números almacenados en notación decimal
unlock(m,OL,256); // desbloquea 256 bytes codificado a binario (BCD) y proporciona hasta 17 dígitos decimales de
precisión, y un rango de 1 × 10-125 a 1 × 10125.
Funciones relacionadas: lock, sopen.

F.12. FUNCIONES MATEMÁTICAS abs versión real #include <math.h>


#include <stdlib.h>
El C original de K&R fue diseñado, inicialmente, como un lenguaje de pro- versión compleja #include <complex.h>
gramación de sistemas, su uso ha sido muy escaso en el campo del cálculo
científico. Sin embargo, desde la normalización de ANSI C y su extensa int abs (int x);
biblioteca matemática, C se ha convertido en un fuerte rival del lenguaje double abs(complex x);
científico por excelencia, FORTRAN. C soporta operaciones de coma flo-
tante e incluye también un rico conjunto de funciones matemáticas. Borland Proporciona el valor absoluto de un entero o de un número complejo:
C++ ha ampliado las propiedades de ANSI C estándar. abs(-50) devuelve 50. Para utilizar números complejos se requiere el
Los archivos de cabecera que contienen funciones matemáticas son: archivo de cabecera complex.h.
bcd.h, complex.h, float.h, math.h, stdlib.h. Las funciones de Bor-
land C++ no incluidas en ANSI C son: cabs, _clear87, _control87, x = abs(-7) // x es 7
_fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min,
poly, pow10, random, randomize, _rotl, _rotr, _status87. Funciones relacionadas: cabs, fabs, labs.
Además de estas funciones, Borland C++ soporta dos clases específicas
importantes: complex y bcd, se encuentran en los archivos complex.h y
bcd.h, respectivamente. acos #include <math.h>
#include <complex.h>
Clase complex
double acos(double x);
Borland C++ incluye una estructura complex en el archivo de cabecera complex acos(complex x);
math.h, cuyos miembros son la parte real e imaginaria de un número com-
plejo z y que se define así: La función acos() devuelve el arco coseno de x, cuyo valor debe estar
en el rango –1 a 1. El resultado es un valor (ángulo) entre 0 y π radianes.
struct complex
{ angulo = acos(0.5); // el ángulo devuelto es π/3
double x; // parte real del número complejo
double y; // parte imaginaria del complejo Funciones relacionadas: cos, matherr.
}

Se puede declarar e inicializar un número complejo (x + yi) de esta


forma: arg #include <complex.h>

struct complex z = {1.5,1.5} // z = 1.5 + i1.5; double arg(complex x);


apenf.qxd 26/11/99 14:17 Página 653

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 653

La función arg() devuelve el ángulo, en radianes, de un número en el Calcula el arco tangente de y/x. El resultado es un ángulo de valor
plano complejo. comprendido entre –π y π radianes.

complex z; angulo = atan2(y, x);


double angulo;
z = complex(1.5, 4.5); Funciones relacionadas: atan, matherr, tan.
angulo = arg(z);

Funciones relacionadas: complex, norm, polar. cabs #include <math.h>

double babs(struct complex z);


asin versión real #include <math.h>
versión compleja #include <complex.h> Calcula el valor absoluto de un número complejo almacenado en una
estructura de tipo complex.
double asin(double x);
struct complex z;
double complejo;
Calcula el arco seno del argumento x; el valor de x debe estar com- z.y = 3.5
prendido entre –1 y 1. La función asin() devuelve un valor entre –π/2 y π, z.y = 2.4
el valor de x debe ser en radianes. complejo = cabs(z);
printf(“valor absoluto %lf\n”, complejo);
Z = asin(0.7543);
Funciones relacionadas: fabs, hypot, matherr, sqrt.
Funciones relacionadas: matherr, sin.

ceil #include <math.h>


atan versión real #include <math.h>
versión compleja #include <complex.h> double ceil (double x);

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

Calcula el arco tangente de x. El rango x es –1 a 1. La función atan() redondeo = ceil(5.1) // redondeo es 6


devuelve un valor en el rango de –π/2 a π/2.
Funciones relacionadas: floor.
#include <complex.h>
complex atan(complex x);
_clear87 #include <float.h>
angulo = atan(1.0); // ángulo es “Pi/4” (45 grados)

unsigned int _clear87(void);


Funciones relacionadas: atan2.
Borra (limpia) la palabra del estado de coma flotante.

atan2 #include <math.h> estado = _clear87();

double atan2 (double y, double x); Funciones relacionadas: _control87, _status87.


apenf.qxd 26/11/99 14:17 Página 654

654 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

_control87 #include <float.h> La función div() calcula el cociente entero y el resto de x por y. La
función devuelve una estructura div_t definida en stdlib.h como
unsigned int _control87(unsigned int nuevo, unsigned int
mascara); typedef struct
{
int quot; // cociente
Obtiene y establece la palabra de control de coma flotante. Cuando se int rem; // resto
utiliza un coprocesador matemático 8087, _control87 establece su palabra } div_t;
de control.
div_t resultado;
estado = control87(PC24,MCW_IC); resultado = div(35, 8);
// precisión 24 bits // resultado.cociente = 4, resultado.resto = 3
Funciones relacionadas: _clear87, _status87.

exp #include <amth.h>


cos #include <math.h> #include <complex.h>

double cos(double x); double exp(double x);


complex cos(complex x); complex exp(complex x);

Calcula el coseno del argumento x. El argumento x se especifica en Calcula el exponencial de x:ex; donde e es la base del logaritmo natu-
radianes y devuelve un valor en el rango de –1 a 1. ral (e = 2.7182818).
coseno_x = cos(1.6543); x = 100.00;
y = exp(x);
Funciones relacionadas: acos, sin. printf(“El exponencial de x = %f.\n”,y);

Funciones relacionadas: log, pow.


cosh #include <math.h>

double cosh(double x);


complex cosh(complex x); fabs, fabsl #include <math.h>

Calcula el coseno hiperbólico de la variable x. Si el argumento pasado double fabs(double x);


a cosh() es demasiado grande, se produce un error de rango. long double fabs(long double x);

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


printf(“x = %f.\n\n”,x);
y = cosh(x);
y = fabs(-7.25); // y vale 7.25
printf(“coseno hiperbólico x = %f.\n\n”, y);

Funciones relacionadas: sinh. Funciones relacionadas: cabs.

div #include <stdlib.h> floor #include <math.h>

div_t div(int x, int y); double floor(double x);


apenf.qxd 26/11/99 14:17 Página 655

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 655

Redondea por defecto el valor de x. double x, y;


int n;
x = 17.5;
y = frexp(x, &n);
x = floor(6.25); // x vale 6
printf(“frexp(%f, &n) = %f, n = %d\n”,x,y,n);
Funciones relacionadas: ceil.
Funciones relacionadas: exp, ldexp, modf.

fmod #include <math.h> hypot #include <math.h>

double fmod(double x, double y); double hypot(double x, double y);

Calcula el resto de la división real x por y. Calcula la hipotenusa de un triángulo rectángulo cuyos lados son x e y.
Una llamada a hypot equivale a lo siguiente:
resto = (fmod(5.0, 2.0); // resto igual a 1.0
sqrt(x * x, y * y);
Funciones relacionadas: floor.
double x = 3.0; y = 4.0;
printf(“%lf”, hypot(x, y));

_fpreset #include <float.h>


imag #include <complex.h>
void _fpreset(void);
double imag(complex x);
Reinicializa el paquete matemático de coma flotante. Debe utilizarse
después de las llamadas a las funciones system(), exec(), span() sobre Devuelve la parte imaginaria de un número complejo x. Esta función no
máquinas con coprocesadores matemáticos. es transportable.
_fpreset(); // inicializa paquete de coma flotante *t double x = 3.4, y = 4.5;
complex = complex(x, y);
Funciones relacionadas: _control87, signal. cout << “parte imaginaria:” << imag(z) << “\”;

Funciones imaginarias: complex, conj, real.

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


labs #include <math.h>
double frexp(double x, int *exp);
long int labs(long int n);
long double frexpl(long double x, int *exp);
Calcula el valor absoluto de un entero largo (n).
La función frexp descompone el valor x en una mantisa (m) y en un
exponente n, tal que el valor absoluto de m es mayor o igual a 0,5 y menor long lx = –51654L, ly;
que 1,0 y x + m*2n. La mantisa se obtiene por la función, y el exponente se ly = labs(lx);
almacena en la variable apuntada por exp.frexpl descompone un valor
long double. Funciones relacionadas: abs, cabs, fabs.
apenf.qxd 26/11/99 14:17 Página 656

656 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

ldesp, ldespl #include <math.h> stderr, la variable global errno toma el valor EDOM y devuelve el valor
HUGE_VAL. Si x es 0, la función imprime un mensaje de error SING en
double ldesp(double x, int exp); stderr, devuelve el valor HUGE_VAL y fija errno a ERANGE.
long double ldexpl(long double x, int exp);
hdouble x, y;
x = 10;
Calcula y devuelve el valor real de x*eexp. y = log(x);
y = log10(x);
double x = 4.0,y;
int p = 5;
y = ldexp(x, p); Funciones relacionadas: exp, matherr pow.

Funciones relacionadas: frexp, modf.


_lrotl #include <stdlib.h>

ldiv #inxlude <stdlib.h> unsigned long _lrotl(unsigned long x, int c);

ldiv_t ldiv(long int x, long int y); Se utiliza _lrotl para rotar a la izquierda los bits de una variable ente-
ra larga sin signo x. La rotación de un bit a la izquierda, una posición, sig-
Calcula el cociente y el resto de la división x/y. La función ldiv nifica que el bit más a la izquierda sale fuera y se inserta en su posición el
devuelve una estructura de tipo ldiv_t que comprende el cociente y el siguiente bit de mayor peso, y los restantes bits se desplazan una posición a
resto. la izquierda.

typedef struct unsigned long x = 0x0fac45491;


printf(“x desplazado 4 veces es”, _lrotl (x, 4);
{
long quot; Funciones relacionadas: _lrotr, _rotl, _rotv.
long rem;
} ldiv_t;
_lrotr #include <stdlib.h>
long x = 5258625, y = 341654;
ldiv_t resultado; unsigned long _lrotr(unsigned long x, int c);
resultado = ldiv(x, y);
printf(“el cociente y el resto es %ld, %ld,\n”, resultado.quot, Rota a la derecha los bits de x. Rotación a derecha de un bit significa
resultado.rem); salir fuera el bit de menor peso y los restantes se desplazan una posición a
la derecha.
Funciones relacionadas: div.
val_r = _lrotr(x, 4);

log, log10 #include <math.h> Funciones relacionadas: _lrotl, _rotl, _rotr.


#include <complex.h>

double log(double x); matherr #include <math.h>


double log10(double x); _matherrl

Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x. int matherr(struct exception *e);
Si x es negativo, ambas funciones devuelven un error de dominio DOMAIN en int _matherrl(struct _exception1 *e)
apenf.qxd 26/11/99 14:17 Página 657

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 657

Esta función manipula errores matemáticos. Las funciones matemáticas polar #include <complex.h>
llaman a la rutina adecuada matherr cuando se detecta un error. Se puede
desarrollar su propia versión de matherr para personalizar su tratamiento complex polar(double modulo, double angulo);
de errores. Para profundizar en esta función, consultar su referencia en
Library Reference de Borland C++ (págs. 352-353). Devuelve un número complejo con una magnitud (módulo) y ángulo
dado.
Funciones relacionadas: Las funciones matemáticas.
complex < = complex(x, y);

max #include <conio.h> polar(mag, ang)es lo mismo que complex(mag*cos(ang), mag


*sin(ang);
(tipo) max(a, b);

Devuelve el mayor de dos valores. Ambos argumentos y la declaración Funciones relacionadas: Sólo existe en C+.
de la función deben ser del mismo tipo.
double dbl1, dbl2, dblmax; poly #include <math.h>
dblmax = max(dbl1, dbl2);
double poly(double x, int n, double c[]);
Funciones relacionadas: min.
Se utiliza poly para evaluar un polinomio en x, de grado n y cuyos coe-
ficientes son los correspondientes al array c. La expresión utilizada para
min #include <stdlib.h> evaluar el polinomio es:
(tipo) min(a, b); c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]
Devuelve el menor de dos valores. Ambos argumentos y la declaración
// polinomio: 3x**2 + 2x + 1//
de la función deben ser del mismo tipo.
double c[] = {-10.0,2,c);
int i1, i2, minent;
minent = min(i1, i2); Funciones relacionadas: pow.
Funciones relacionadas: max.
rand #include <stdlib.h>

modf, modfl #include <math.h> int rand(void);

double modf(double x, double *partent); Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; esta
long double modfl(long double x, long double *partent); constante simbólica está definida en <stdlib.h> y su valor es 215-1. Para ini-
cializar el generador de números pseudoaleatorios se debe utilizar randomize.
La función modf divide un número de coma flotante en dos partes, ente-
Para obtener un número en el rango de 0 a (n-1) hay que utilizar random.
ra y decimal. La parte entera de x se almacena en la posición a cuya direc-
ción apunta partent, y la parte decimal es devuelta por la función. // visualizar 10 números aleatorios //
for(i = 0; 1 < 10; i++)
pardecimal = modf(36.95, &parte_entera(;
// parte entera 36, parte decimal .95 printf(“%6d\”, rand());

Funciones relacionadas: frexp,ldexp. Funciones relacionadas: random, randomize, srand.


apenf.qxd 26/11/99 14:17 Página 658

658 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

random #include <stdlib.h> Rota el valor de x,c bits a la izquierda.

modelo_nuevo = _rotl(0x1234,8);
int random(int x);
// resultado es 3412h
Genera un número pseudoaleatorio en el rango de 0 a x-1.
Funciones relacionadas: _lrotl, _rotr, _rotr.
// obtener un número aleatorio entre 0 y 20
numa1 = random(21);
_rotr #include <stdlib.h>
Funciones relacionadas: rand, randomize.
unsigned _rotr(unsigned x, int c);

Se utiliza _rotr para rotar a la derecha el valor de x,c bits.


randomize #include <stdlib.h>
#include <time.h> _rotr(val, 4);

void randomize(void); Funciones relacionadas: _lrotl, _lrotr, _rotl.


Inicializa (genera una semilla) el generador de números pseudoaleato-
rios con una semilla aleatoria que es función de la hora actual. Esta función sin #include <math.h>
impide que se repitan las mismas secuencias de números aleatorios en dife- #include <complex.h>
rentes ejecuciones.
double sin(double x);
randomize(); complex sin(complex x);

Funciones relacionadas: rand, random, srand. La función sin() proporciona el seno de x (se supone en radianes).
double x, y;
real #include <complex.h> x = 0.52;
#include <bcdh.h> printf(“x = %f radianes\n”, x);
y = sin(x)
printf(“el seno de x = %f\n”, y);
double real(complex x);
double real(bcd x); Funciones relacionadas: asin, cos, sinh.
Devuelve la parte real de un número complejo x o convierte un número
BCD a float, double o long double. sinh #include <math.h>
#include <complex.h>
complex z = complex(x, y)
cout << “parte real:” << real(z) << “\n”;
double sinh(double x);
complex sinh(complex x);
Funciones relacionadas: Función exclusiva de C++.
Devuelve el seno hiperbólico de x (x, se supone en radianes).
_rotl #include <stdlib.h> y = sinh(x);

unsigned _ rotl(unsigned x, int c); Funciones relacionadas: sin, cosh.


apenf.qxd 26/11/99 14:17 Página 659

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 659

sqrt #include <math.h> tanh #include <math.h>


#include <complex.h>
double sqrt(double x);
complex sqrt(complex x); double tanh(double x);
complex tanh(complex x);
Calcula la raíz cuadrada de un número x no negativo.
Calcula la tangente hiperbólica de x.
printf(“%lf”,sqrt(25.0); // se visualiza 5
a = tanh(x);
Funciones relacionadas: exp, log, pow.
Funciones relacionadas: cosh, tanh.
srand #include <stdlib.h>

void srand(unsigned x); F.13. FUNCIONES DE MANIPULACIÓN DE BLOQUES


DE MEMORIA (BUFFERS)
srand inicializa el generador de números aleatorios con la semilla x. Si
x es 1, el generador se reinicializa; cualquier otro valor de x fija el genera- Las rutinas de manipulación de buffers son una forma general de las rutinas
dor a un punto inicial aleatorio. de manipulación de cadenas que operan sobre éstas en C. Son útiles para tra-
bajar con áreas de memoria sobre la base de carácter a carácter. Un buffer es
srand(semilla); un array de caracteres similar a una cadena de caracteres. Sin embargo, al
contrario que las cadenas, los buffers no terminan normalmente con un
Funciones relacionadas: rand, randomize. carácter nulo (´\0´). Por consiguiente, las rutinas de manipulación de buf-
fers siempre toman un argumento longitud o cuenta.
Las rutinas de manipulación requieren que el archivo de cabecera
_status87 #include <float.h> <mem.h> se incluya en su programa.

unsigned int _status87(void);

Obtiene el contenido de la palabra de estado de coma flotante. memccpy #include <mem.h>


#include <string.h>
estado = _status87();
void *memccpy(void *dest, const void *s, int c, size_t n);
Funciones relacionadas: _clear87, _control87.
Copia n bytes desde s a dest hasta que n bytes han sido copiados o c
se copia a dest.
tan #include <math.h>
#include <complex.h> res = memccpy(buf_dest, bufen, ´c´, 81);

double tan(double x); Funciones relacionadas: memcpy, memmove, movedata, movmem.


complex tan(complex x);

Calcula la tangente de x (x, se supone en radianes).


memchr #include <mem.h>
y = tan(x) #include <string.h>

Funciones relacionadas: atan. void *memchr(const void *buf, int c, size_t n);
apenf.qxd 26/11/99 14:17 Página 660

660 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Busca un carácter específico c en un buffer (buf) examinando los n pri- memmove #include <string.h>
meros caracteres. #include <mem.h>
result = memchr(direc, ´I´, 40);
void *memmove(void *dest, const void *f, size_t n);
Funciones relacionadas: memcmp, memicmp.
Mueve n bytes de un buffer (f) a otro (dest).

Funciones relacionadas: memccpy, memcpy, movedata.


memcmp #include <mem.h>

int memcmp(const void *b1, const void *b2, size_t n);


memset #include <string.h>
Compara n bytes de un buffer (b1) con los de otro buffer (b2). Devuel-
ve un valor: void *memset(void *s, int c, size_t n);

< 0 si b1 < b2 Fija los n primeros bytes del array s al carácter c.


= 0 si b1 = b2
> 0 si b1 > b2 resultado = memset(buffer,´1´, 50);

resultado = memcmp(buf1, buf2, sizeof(buf1)); Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.
Funciones relacionadas: memicmp.
movedata #include <mem.h>
#include <string.h>
memcpy #include
void movedata (unsigned ss, unsigned so,
void *memcpy(void *dest, const void *fuente, size_t n); unsigned ds, unsigned do, size_t n);
Copia n bytes de fuente en dest. Devuelve un puntero a dest.
Mueve n bytes desde ss a ds, donde ss es el segmento fuente, so es el
memcpy(dest, fuente, 80): desplazamiento fuente, ds es el segmento destino, do es el desplazamiento
destino y n es el número de bytes que hay que mover.
Funciones relacionadas: memccpy, memmove, movedata.
movedata(seg1, off, seg2, dest_off, 4096);

memicmp #include <mem.h> Funciones relacionadas: memcpy, memmove, movmem, segread.


#include <string.h>

int memicmp (const void *b1, const void *b2, size_t n); movmem #include <mem.h>

Compara un número de bytes de un buffer (b1) con otro (b2) sin hacer void movmem(void *fuente, void *destino, unsigned n);
caso del tamaño de las letras en los dos buffers.
Copia n bytes de fuente a destino.
if(memicmp(buf1, buf2, 15) == 0)
puts(“Los buffers son iguales en los 15 primeros bytes \n”); movmem(&fuente[6], fuente, sizeof(fuente));

Funciones relacionadas: memcmp. Funciones relacionadas: memmove.


apenf.qxd 26/11/99 14:17 Página 661

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 661

setmem #include <mem.h> clrscr #include <conio.h>

void setmem(void *dest, unsigned long, char c); void (clrscr(void);

Fija un bloque de long bytes en el buffer dest al carácter c. setmem es Borra la ventana actual y pone el cursor en la esquina superior izquier-
útil para inicializar buffers. da (1,1).

setmem(buffer, 60, ´t´); clrscr();

Funciones relacionadas: memset. Funciones relacionadas: clreol, textbackground, window.

swab #include <stdlib.h> delline #include <conio.h>

void swab(char *fuente, char *destino, int n); void delline(void);

Copia un número par de bytes de una posición a otra, intercambiando al Borra la línea completa que contiene el cursor y desplaza hacia arriba
mismo tiempo cada par de bytes adyacentes. las líneas que haya debajo.

swab(“mnpq”, resultado, 4); delline();


// resultado es “nmpq”
Funciones relacionadas: clreol, clrscr.
Funciones relacionadas: Sólo está disponible en sistemas UNIX.

gettext #include <conio.h>

F.14. FUNCIONES DE PRESENTACIÓN DE TEXTO int gettext(int izda, int arriba, int derecha, int abajo,
void *textbuf);
Las funciones de presentación de texto permiten definir coordenadas de una
ventana de texto en la pantalla y manipular texto. Con estas funciones se Copia el contenido de un área rectangular de la pantalla al buffer cuya
puede posicionar texto en cualquier parte de la pantalla, seleccionar atribu- dirección se da en el argumento textbuf. Todas las coordenadas son abso-
tos de texto (tales como subrayado, vídeo inverso, parpadeo, colores de lutas.
fondo y primer plano), así como actuar sobre ventanas de texto. Estas fun-
ciones se encuentran esencialmente en el archivo de cabecera conio.h. if(!gettext(1,1,30,20, pan_grabada))
puts(“color”);

clreol #include <conio.h> Funciones relacionadas: movetext, puttext.

void clreol(void);
gettextinfo #include <conio.h>
Borra la línea actual desde la posición del cursor al final de la línea.
void gettextinfo(struct text_info *r);
clreol()
Devuelve información relativa a las coordenadas de la ventana actual,
Funciones relacionadas: clrscr, delline, textbackground, window. posición del cursor dentro de la ventana, atributo del texto, las dimensiones
apenf.qxd 26/11/99 14:17 Página 662

662 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

de la pantalla y el modo de texto actual. La información se devuelve en una Inserta una línea en blanco en la ventana de texto actual en la posición
estructura text_info. del cursor, desplazando el resto de las líneas situadas debajo.

struct text_info { insline();


unsigned char winleft; // coordenadas x, y esquina superior
// izquierda Funciones relacionadas: clreol, delline, window.
unsigned char wintop; // ventana actual
unsigned char winright; // coordenadas x, y esquina inferior
// derecha
unsigned char winbottom; // ventana actual lowvideo #include <conio.h>
unsigned char attribute; // atributo texto actual
unsigned char normattr; // atributo texto normal void lowvideo(void);
unsigned char currmode; // modo texto actual
unsigned char screenheight;// altura de la pantalla Activa los caracteres a baja intensidad.
unsigned char screenwidth; // anchura pantalla
unsigned char curx; // coordenada x cursor
unsigned char cury; // coordenada y cursor lowvideo();
};
Funciones relacionadas: highvideo, normvideo, textcolor.

gotoxy #include <conio.h>


movetext #include <conio.h>
void gotoxy(int x, int y);
iont movetext(int izda, int arriba, int dcha,
Mueve el cursor a una posición especificada (columna x, fila y) dentro int abajo, int nuevoizda, int nuevoarriba);
de la ventana de texto actual.
Copia el contenido de una zona rectangular de la pantalla (en modo
gotoxy(15, 4); texto) a otro rectángulo en la pantalla de las mismas dimensiones.

Funciones relacionadas: wherex, wherey, window. if (!movetext(1, 1, 30, 20, 40, 40))
puts(“victoria”);

highvideo #include <conio.h> Funciones relacionadas: gettext, puttext.

void highvideo(void);
normvideo #include <conio.h>
Activa caracteres de alta intensidad.
void normvideo(void);
highvideo();
Reinicializa los atributos de texto al valor que tenían antes de que arran-
Funciones relacionadas: lowvideo, normvideo, textcolor. que el programa.

normvideo();
insline #include <conio.h>
Funciones relacionadas: highvideo, lowvideo, textattr, textco-
void insline(void); lor.
apenf.qxd 26/11/99 14:17 Página 663

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 663

puttext #include <conio.h> textbackground #include <conio.h>

int puttext(int izda, int arriba, int dcha, int abajo, void textbackground(int colorfondo);
void *textbuf);
Establece el color de fondo para texto vidualizado.
Copia el contenido de un buffer en una zona rectangular de la pantalla
en modo texto.
textbackground(2);
puttext(3, 1, 32, 22, buffertexto);

Funciones relacionadas: gettext, movetext. textcolor #include <conio.h>

void textcolor(int colorprimerplano);

_setcursortype #include <conio.h> Establece el color del primer plano del texto visualizado por cprintf y
cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15
void setcursortype(int estilo_cursor); WHITE (blanco).

Cambia la forma del cursor en modo texto. El argumento tiene que ser textcolor(15);t
una de las constantes.
Funciones relacionadas: textattr, textbackground.
_NOCURSOR Desactiva el cursor.
_SOLIDCURSOR Un carácter bloque sólido es el cursor.
_NORMALCURSOR Un subrayado parpadeante es el cursor.
setcursortype(_SOLIDCURSOR); texmode #include <conio.h>

Funciones relacionadas: cprintf, cputs. void textmode(int nuevomodo);

Conmuta al modo texto especificado por el argumento nuevomodo.

textattr #include <conio.h> -1 LASTMODE Último modo de texto.


0 BW40 Monocromo 40 columnas.
void textattr(int atrib); 1 C40 Color 40 columnas.
2 BW80 Monocromo 80 columnas.
Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia
3 C80 Color 80 columnas.
del texto en la pantalla.
7 MONO Monocromo 80 columnas.
textattr(YELLOW + (RED << 4));
64 C4350 EGA 43 filas o VGA 50 filas.
textattr(10110100);
textmode(C40);
Funciones relacionadas: gettextinfo, highvideo, lowvideo, norm-
video, textbackground, textcolor. Funciones relacionadas: gettextinfo, restorecrtmode.
apenf.qxd 26/11/99 14:17 Página 664

664 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

wherex #include <conio.h> window #include <conio.h>


wherey
void window(int izda, int arriba, int dcha, int abajo);
int wherex(void); Define una región rectangular de la pantalla como la ventana de texto
int wherey(void); actual esquina superior izquierda (izda, arriba) y esquina inferior dere-
cha (dcha, abajo).
Determina la coordenada x (wherex) y la coordenada y (wherey) de la
posición del cursor en la ventana actual. window(15, 5, 54, 14);
// ventana de 40 x 10 con origen en (15, 5)

xpos = where(x); ypos = where(y); Funciones relacionadas: gettextinfo, textmode.