F. Biblioteca de funciones estándar ANSI/ISO C++

APÉNDICE F
BIBLIOTECA DE FUNCIONES ESTÁNDAR
ANSI/ISO C++ Y BORLAND C++ 5.0
CONTENIDO
F.1.
F.2.
F.3.
F.4.
F.5.
F.6.
F.7.
Plantilla referencia de entradas.
Funciones de asignación de memoria.
Funciones de búsqueda y ordenación.
Funciones de cadena.
Funciones de clasificación de caracteres.
Funciones de calendario (fecha y hora).
Funciones de control de directorios.
F.8. Funciones de control de procesos.
F.9. Funciones de conversión de datos.
F.10. Funciones de entrada/salida.
F.11. Funciones de gestión de archivos.
F.12. Funciones matemáticas.
F.13. Funciones de manipulación de bloques de memoria (buffers).
F.14. Funciones de presentación de texto.
Esta parte es una revisión breve de la biblioteca de rutinas (funciones) y
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
diseñadas para su uso en programas C++. La biblioteca en tiempo de ejecución
hace la programación más fácil, ya que incluye una amplia variedad de
tareas tales como E/S de bajo y alto nivel, manipulación de cadenas y archivos,
asignación de memoria, control de procesos, cálculos matemáticos, etc.
Las rutinas de Borland C++ están contenidas en los archivos de biblioteca
Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ implementa
la versión estándar última de ANSI C, que entre otras cosas recomienda
el uso de los prototipos de función en las rutinas de sus programas C++.
Este apéndice describe alfabeticamente funciones de la biblioteca Borland
C++ y contiene todas las funciones incluidas en ANSI/ISO C++.
F.1.
PLANTILLA REFERENCIA DE ENTRADAS
Las entradas de las diferentes funciones y macros han sido normalizadas
para facilidad de manejo del lector. Las rutinas han sido clasificadas por
categorías (en general, se ha procurado respetar la clasificación dada por
Borland y ANSI, pero con una adaptación más próxima al uso diario del
programador /.
Al comienzo de cada categoría se hace una breve descripción de su
cometido principal y se presenta una tabla con las funciones que contiene
cada categoría por orden alfabético, así como una breve síntesis de su descripción
o propósito. A continuación, por orden alfabético, se describen las
rutinas de acuerdo al siguiente modelo para cada entrada.
F.2.
FUNCIONES DE ASIGNACIÓN DE MEMORIA
Borland C++ almacena información en la memoria principal de la computadora
por dos métodos. El primero utiliza variables globales y locales
(incluyendo arrays, cadenas y estructura); en este caso, el almacenamiento
o longitudes fija. Para cambiar el tamaño de arrays y cadenas de caracteres
se debe editar el archivo fuente y recompilar su programa. Esta información
se almacena en la pila (stack). El segundo método de almacenar información
es asignar memoria a medida que el programa lo requiera y liberar esta
memoria cuando ya no se necesita; esta acción permite utilizar la misma
nombre función
• strrev
char *strrev(char *cad)
sintaxis
archivo de cabecera
#include
Descripción
Propósito y breve descripción de cómo y dónde se utiliza la función.
Ejemplo
Una o más instrucciones o programas sencillos, donde se muestra la explicación
real de la función.
Funciones relacionadas: strcpy, strncpy.
Funciones relacionadas con la función descrita.

616 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
memoria para colas diferentes en un tiempo distinto. Este proceso de asignar
memoria se denomina asignación dinámica de memoria.
Por omisión, cada vez que se ejecuta un programa, DOS establece un
segmento de 64 Kb denominado segmento de código, que contiene su código
programa. DOS establece también un segmento de 64 Kb denominado
segmento de datos. Su programa puede tener múltiples segmentos de datos
y códigos.
El segmento de datos se divide en tres regiones: datos del programa
(variables estáticas y globales), pila —stack— (variables locales y argumentos)
y montón o montículo —heap.
Segmento de datos
Montículo Pila Datos del programa
(heap)
(stack)
Después de asignar partes del segmento de datos a variables estáticas y
globales y a la pila, el compilador dedica el resto del segmento de datos al
montículo o heap.
Borland C++ contiene un gran número de funciones para asignación
dinámica de memoria, que realizan una gran variedad de tareas: asignar y
liberar memoria del montículo y de la pila, obtener información de bloques
de memoria, etc.
datos de un programa. Si hay éxito se devuelve 0; en caso contrario, –1, y la
variable global errnoc toma el valor ENOMEN (insuficiente memoria).
it(brk(nuevo_break) == -1)
perror(“brk ha fallado”);
Funciones relacionadas: free, farmalloc, malloc, sbrk.
calloc
int *calloc(size_t n, size_t s);
#include
#include
Asigna memoria principal (un bloque de tamaño n.s). El bloque se
borra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debe
utilizar farcalloc. Devuelve un puntero al bloque recién asignado. Si no
existe bastante espacio para el nuevo bloque o bien n o s es 0, calloc
devuelve nulo.
long *buffer
buffer=(long *) calloc(40, sizeof(long));
Funciones relacionadas free, malloc.
allocmen
int allocmen(unsigned t, unsigned * seg);
#include
La función allocmen() establece seg para apuntar a un segmento asignado
de memoria de t párrafos (1 párrafo = 16 bytes) de largo. Si hay éxito
se devuelve –1, si hay error (falta memoria), allocmen() devuelve el
tamaño en párrafos del mayor bloque disponible.
if(allocmen(size, &segadd)!= -1)
printf (“Error asignación memoria \n”);
Funciones relacionadas: falloc frremem, malloc, setblock.
brk
#include
int brk( void* a)
La función brk permite modificar el «valor break» de un programa. El
valor break es la dirección de la primera posición más allá del segmento de
coreleft
#include
unsigned coreleft(void) // modelos small, tiny, medium
unsigned long coreleft(void); // en otros modelos de memoria
Determina la cantidad de memoria no utilizada. El valor devuelto
depende del modelo de memoria.
Mem_avail = coreleft();
Funciones relacionadas: calloc, farcoreleft, malloc.
farcalloc
#include
void far *farcalloc(unsigned long n, unsigned long s);
Esta función asigna n piezas de tamaño s y las pone a 0. Un puntero al
principio de la memoria asignada se devuelve si farcalloc() tiene éxito;
en caso contrario se devuelve NULL.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 617
if(array_grande=farcalloc(20000L, sizeof (int)) “” NULL)
printf (“Fallo en asignación de memoria\n”);
Funciones relacionadas: farheapfillfree, farheapwalk, heapfillfree,
heapcheckfree, heapwalk.
Funciones relacionadas: calloc, farfree, farmalloc, malloc.
farheapchecknode
#include
farcoreleft
unsigned long farcoreleft(void);
#include
int farheapchecknode(void *bloque);
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();
Funciones relacionadas: coreleft, farcalloc, farmalloc.
farheapfillfree
int farheapfillfree(unsigned int f);
#include
farfree
void farfree(void far *b);
Libera la memoria apuntada por b.
farfree(arraygrande);
#include
Rellena todos los bloques libres del montículo far con un valor constante.
estadoheap = farheapfillfree(´X´);
Funciones relacionadas: farheapcheckfree, farheapchecknode,
farheapwalk, heapfillfree, heapwalk.
Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.
farheapwalk
#include
farheapcheck
#include
int farheapcheck(void);
Verifica la consistencia del montículo (heap) far.
estadoheap = farheapcheck();
Funciones relacionadas: farheapcheckfree, farheapchecknode,
farheapwalk, heapfillfree, heapwalk, heapcheck.
farheapcheckfree
#include
int farheapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montículo (heap) far.
estadoheap = farheapcheckfree(´F´);
int farheapwalk(struct farheapinfo *m);
Obtiene información sobre las entradas en el montículo (heap) far.
struct farheapinfo heap_entry;
estadopila = farheapwalk(&heap_entry);
farmalloc
void far *farmalloc(unsigned long n);
#include
Asigna n bytes de memoria far. La cantidad completa de memoria
encima de la pila está disponible para asignación por farmalloc. El tamaño
del bloque puede exceder de 64 Kb.
if(bloquegrande = farmalloc(80000L) == NULL
printf(“Asignación fallada\n”);
Funciones relacionadas: calloc, farfree, farcalloc, malloc.

618 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
farrealloc
#include
heapcheckfree
#include
void far *farrealloc(void far *b, unsigned long n)
Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b,
al cual se ha asignado una longitud de n bytes).
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL
printf(“Fallo reasignación memoria\n”);
int heapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montículo (heap).
estadoheap = heapcheckfree(´N´);
Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.
Funciones relacionadas: calloc, farcalloc, farfree, malloc.
heapchecknode
#include
free
vid free(void *dir_memoria);
#include
#include
int heapchecknode(void *n);
Verifica la consistencia de un solo nodo (bloque de memoria). Verifica
el bloque de memoria identificado por el puntero n.
La función free() libera un bloque de memoria. El argumento
dir_memoria apunta a un bloque de memoria previamente asignado a
través de una llamada a calloc, malloc o realloc. Después de la llamada
el bloque libre está disponible para asignación.
char *cad;
// asignar memoria para cadena
cad = (char *) malloc(50);
...
free(cad); // liberar memoria
Funciones relacionadas: calloc, malloc, realloc
estadopila = heapchecknode(array);
Funciones relacionadas: farheapchecknode, heapcheck, heapcheckfree,
heapfillfree, heapwalk.
heapfillfree
int heapfillfree(unsigned int f);
#include
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
equivalente es –heapset.
heapcheck
int heapcheck(void);
#include
estadopila = heapfillfree(´Z´);
Funciones relacionadas: farheapfillfree, heapcheck, heapcheckfree,
heapwalk.
Verifica la consistencia del montículo (heap). En Visual C++ 6.0 la función
equivalente es _heapcheck();
estadoheap = heapcheck();
heapwalk
int heapwalk(struct heapinfo *i);
#include
Funciones relacionadas: heapcheckfree, heapchecknode, heapfillfree,
heapwalk, farheapcheck.
Se utiliza para obtener información sobre las entradas en el montículo
(heap). La función equivalente en Visual C++ es _heapwalk.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 619
struct heapinfo i;
estadoheap = heapwalk(&i);
Funciones relacionadas: farheapwalk, heapcheck.
malloc
void *malloc (size_t n);
#include
#include
Asigna memoria a bloques en el montículo. Devuelve un puntero, que
es la dirección inicial de la memoria asignada.
cadena = malloc(MAX_CHR)
Funciones relacionadas: calloc, free, realloc.
setblock
int setblock(unsigned seg, unsigned n);
#include
Ajusta el tamaño de un bloque de memoria asignado anteriormente por
allocmen. Esta función llama a la función 4Ah de DOS para ampliar el
tamaño de un bloque de memoria previamente asignado por allocmen. En
las versiones Visual C++ la función equivalente es _dos_setblock.
F.3.
FUNCIONES DE BÚSQUEDA Y ORDENACIÓN
La mayoría de los programas requieren casi siempre alguna operación de
clasificación y búsqueda de elementos en arrays. Borland C++ incluye diferentes
funciones que realizan estas tareas.
bsearch()
#include
realloc
#include
#include
void bsearch(const void*k, const void *b, size_t n, size_t a,
int(*comparar)(const void*, const void*));
void *realloc(void *b, size_t n);
Ajusta el tamaño de un bloque de memoria b asignado por malloc o
calloc a un tamaño de n bytes. Devuelve un puntero void al bloque de
memoria reasignado.
Nuevo_buffer = realloc(viejo_buffer, long+100);
Funciones relacionadas: calloc, free, malloc.
La función bsearch realiza una búsqueda binaria en un array ordenado
b, de n elementos, cada uno de a bytes de tamaño. El argumento k apunta
al valor que se está buscando. bearch devuelve un puntero (la dirección)
a la primera aparición del valor k en el array. Si no se encuentra el valor,
bsearch devuelve o.
El argumento comparar proporciona la dirección de una rutina que
aceptará dos argumentos elem1 y elem2, cada uno un puntero a un elemento
del array. La función comparar compara cada uno de los elementos apuntados
y devuelve un valor de acuerdo con la tabla siguiente:
sbrk
void *sbrk(int n);
#include
Se utiliza sbrk para indicar el valor break de un proceso. El valor
break es la dirección del primer byte disponible en el segmento de datos por
omisión, más allá del segmento de datos que está siendo utilizado por los
datos en el proceso.
sbr(500);
Funciones relacionadas: brk, coreleft
Valor devuelto
Negativo
Cero
Positivo
Condición
Primer elemento menor que el segundo (elem1) (elem2).
Los dos elementos son idénticos.
Primer elemento mayor que el segundo.
La búsqueda binaria requiere que el array esté ordenado, por lo cual,
caso de que no esté ordenado el array, se puede utilizar la función qsort
para ordenar el array antes de llamar a bsearch.
Funciones relacionadas: lfind, lsearch, qsort.

620 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
lfind
#include
void * lfind(const void k, const void *b, size_t *num, size_t
anchura, int(*comparar)(const void*, const void*));
La función lfind() realiza una búsqueda lineal de valor de k (clave) en
un array de un número específico de elementos, cada uno de un número fijo
de bytes de longitud. Al contrario que bsearch(), el array no necesita
estar ordenado. lfind() devuelve un puntero al primer elemento del array
que coincide con la clave; si la clave no existe en el array, se devuelve un 0.
int comp(const void*, const void *); resultado = (char **)
lfind(palabrabuscada, envp, &cuenta, sizeof(char*), comp);
Funciones relacionadas: bsearch, lsearch, qsort.
lsearch
#include
void * lsearch(const void *k, const void *a, size_t *n, size_t W,
int(*comparar) (const void*, const void *));
La función lsearch realiza una búsqueda lineal de la clave k. El
array a contiene n elementos de anchura W. La función comparar se utiliza
para comparar la clave con el elemento actual del array. Al contrario
que bsearch(), en la función lsearch() el array no tiene que estar
ordenado. lsearch() devuelve un puntero al primer elemento del array
que se corresponde con la clave. Si no existe la clave en el array, se
devuelve 0 y un registro se añade al array con un valor de k.
La diferencia entre lsearch() y lfind() es que lsearch() añadirá
un registro al final del array con un valor de la clave si ese registro no se ha
encontrado en el array.
Funciones relacionadas: bsearch, lfind, qsort.
qsort
#include
void qsort(void a, size_t n, size_t w, int(*comparar) (const void*,
const void*));
La función qsort ordena un array con un número dado de elementos
utilizando el método de ordenación rápida quicksort (creado por C.A.R.
Hoare). El número de elementos de array es n y el tamaño (en bytes) de cada
elemento es w. La función comparar se utiliza para comparar un elemento
del array con la clave; devuelve los siguientes valores:
Valor devuelto
Negativo
Cero
Positivo
Condición
Primer elemento (elem1) menor que el segundo (elem2).
Los dos elementos son idénticos.
Primer elemento mayor que el segundo.
Ordenar la lista de enteros y visualizar el resultado.
#include
#include
int comparar(const void*, const void *);
int numeros[10] = {4,5,7,3,12,8,6,1,0,2};
main(void)
{
int i;
}
printf(“lista original:”);
for(i =0; i < 10; i++)
printf(“%d”, numeros[i]);
qsort(numeros,10,sizeof(int), comparar);
printf(“lista ordenada:”);
for(i = 0; i < 10; i++)
printf(“%10, numeros[i]);
return 0;
// comparar enteros
comparar(const void *i, const void *j)
{
return ((int *)i) – ((int *) j)
}
Funciones relacionadas: bsearch, lfind, lsearch.
F.4.
FUNCIONES DE CADENA
C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan
como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación
el final de una cadena en C se representa por un byte que contiene un carácter
nulo (´\0´). Las cadenas pueden ser declaradas como arrays de caracteres.
char cad[20], cad 5[] = “Hola Mortimer”;

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 621
Acceso a las cadenas
strchr
#include
A las cadenas se accede directamente a través de su índice, como en el
ejemplo anterior, o bien a través de un puntero.
char cad5[] = “Hola Mortimer”;
char *p_cad5;
p_cad5 = cad5;
Se puede también declarar e inicializar una cadena a la vez:
char *p_cad5 = “Hola Mortimer”;
El archivo de cabecera contiene numerosas funciones que
manipulan cadenas.
stpcpy
#include
char *stpcpy(char *cad1, const char *cad2);
La función stpcpy() copia una cadena en otra. Devuelve un puntero al
final de la cadena copiada. Se devuelve el valor de cad1+strlen(cad2)
stpcpy(orden_dos, “DIR”);
stpcpy(caad1, cad2);
Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.
strcat
char *strcat(char *cad1, const char cad2);
#include
strcat() concatena (añade) cad1 al final de cad2, terminando la cadena
resultante con un carácter nulo (\0).
char nombre[80] = “Bob”;
char blanco[2] = “”;
char ultimo[80] = “Marley”;
...
strcat(nombre,blanco); // blanco se concatena a nombre
strcat(nombre,ultimo); // ultimo se concatena a nombre
// la cadena nombre será “Bob Marley”
Funciones relacionadas: strcpy, strdup, strncat, strncpy.
char *strchr(const char *cad, int c);
strchr() encuentra la primera aparición de c en cad y devuelve un
puntero a la primera aparición de c en cad. Si c no se encuentra, devuelve
un cero (NULL).
printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));
visualizará $85725
char *s[81] = “Esta es una cadena de prueba”;
char *ptr;
ptr = strchr(s, ´a´);
el valor almacenado en ptr es un puntero a la primera aparición de ´a´.
strcmp
int strcmp(const char *a, const char *b);
Compara una cadena con otra. Los resultados serían:
> 0 si a > b
= 0 si a == b
< 0 si a < b
i = strcmp(“MNP”, “mnp”); // resultado < 0
i = strcmp(“abc”, “abc”); // resultado = 0
i = strcmp(“xy”, “abc”); // resultado > 0
char s1[80] “ “Mayo”;
char s2[80] = “Octubre”;
int j;
j = strcmp(s1, s2);
#include
Funciones relacionadas: strcmpi, stricmp, strnicmp, strncmp.
strcmpi
#include
int strcmpi(const char *cad1, const char * call2);
Compara una cadena con otra sin diferenciar entre mayúsculas y minúsculas
y devuelve un entero:

622 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
< 0 si cad1 < cad2
= 0 si cad1 = cad2
> 0 si cad1 > cad2
v = strcmpi(c1, c2);
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.
Localiza la posición de la primera aparición en una cadena de cualquier
carácter de otra cadena. Si tiene éxito, la función strcspn devuelve el índice
del primer carácter de cad1, que pertenece al conjunto de caracteres de
cad2.
primero = strcspn(“circunloquio”, “q”);
// primero = 8
Funciones relacionadas: strpbrk, strspn.
strcoll
int strcoll(const char *cad1, const char cad2);
Compara cad1 con cad2. Devuelve un valor.
< 0 si cad1 < cad2
= 0 si cad1 = cad2
> 0 si cad1 > cad2
if(strcoll(nombre1, nombre2)! = 0)
exit(EXIT_FAILURE);
Funciones relacionadas:
strxfrm.
strcpy()
#include
setlocate, strcmp, strcmpi, strncmp,
char *strcpy(char *cad1, const char *cad2);
#include
strcpy() copia cad2 en cad1. Si la longitud de la cadena resultante
excede el tamaño asignado a cad1, puede producir fallos en el programa.
char *a = “Pepe Luis”;
char b[12];
strcpy(b, a);
cout

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 623
strerror
char *strerror(const char *cad);
#include
#include stdio.h
Esta función sirve para generar un mensaje de error definido por el
usuario.
printf(“%S”, _strerror(“error apertura archivo”));
Funciones relacionadas: perror, strerror.
strlwr
char *strlwr(char *cad);
#include
Convierte una cadena en letras minúsculas. La función devuelve un
puntero a la cadena convertida.
char *orden =”SALIR”;
strlwr(orden); // ahora orden = “salir”;
Funciones relacionadas: strupr, toloweer.
stricmp
#include
strncat
#include
it stricmp(const char *cad1, const char *cad2);
Esta función se utiliza para comparar una cadena a otra sin tener en
cuenta el tamaño de las letras. Convierte todos los caracteres alfabéticos de
cad1 y cad2 en minúsculas; a continuación, se comparan las dos cadenas y
devuelve un valor entero que indica el orden lexicográfico de cad1 con respecto
a cad2.
Si cad1 = cad2
Si cad1 < cad2
Si cad1 > cad2
Resultado = stricmp(cad1, cad2),
el valor de la función es cero.
el valor de la función es menor que cero.
el valor de la función es mayor que cero.
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.
char *strncat(char *cad1, const char *cad2, size_t n);
La función strncat() añade los primeros n caracteres de cad2 a cad1,
y termina la cadena resultante un carácter nulo. Si cad2 es mayor que n
caracteres de longitud, strncat() truncará la cadena a la longitud de n. En
otro caso, concatenará la cadena completa.
char *a = “Sierra Madre”;
char *b = “de la ciudad de Monterrey”;
cout

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

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 625
strspn
sze_t strspn(const char *cad1, constchar *cad2);
#include
Localiza la posición del primer carácter de una cadena (cad1) que no
pertenece al conjunto de caracteres de otra (cad2).
loc = strspn (cad1, blanco);
Convierte cualquier letra minúscula de la cadena en mayúscula y
devuelve un puntero a la cadena convertida (sólo alfabeto inglés).
La función strupr y su homónima strlwr no forman parte de la biblioteca
ANSI C. En estos casos, utilice las funciones toupper y tolower.
strupr(“sierra madre”);
Funciones relacionadas: strlwr, toupper.
// “SIERRA MADRE”
Funciones relacionadas: strcmp, strcspn.
strxfrm
#include
strstr
#include
size_t strxfrm(char *cad1, char *cad2, size_t n);
char *strstr(const char *cad1, const char *cad2);
Localiza la primera aparición de una cadena en otra. Si tiene éxito, la
función strstr devuelve un puntero a la primera aparición de cad2 como
una subcadena de cad1. Si la búsqueda falla, se devuelve NULL.
char *s = “Mi autor favorito es Octavio Paz”
char *a = “Octavio Paz”;
cout

626 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
Asimismo, existen otras funciones en el archivo ctype.h que sirven
para convertir caracteres en mayúsculas en minúsculas, y viceversa; y valores
enteros en códigos ASCII.
iscntrl, isdigit
isgraph, islower
isprint, ispunct, isspace
isupper,isxdigit
#include
isalnum
int isalnum(int c);
#include
La función isalnum() devuelve un cero si c es un carácter no alfanumérico
y un valor distinto de cero si el carácter es alfanumérico.
carac = getch();
if(isalnum(carac))
printf(“%c letra|digito \n”, carac);
else
printf(“%c no letra|digito \n”, carac);
Funciones relacionadas: isascii.
int iscntrl(int c);
int isdigit(int c);
int isgraph(int c);
int islower(int c);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isupper(int c);
int isxdigit(int c);
Estas macros sirven para determinar propiedades específicas de un
carácter ASCII.
isalpha
#include
Macro Verifica Rango válido de valores
int isalpha(int c);
La función isalpha() verifica si un carácter es alfabético. Devuelve un
valor distinto de cero si c es un carácter alfabético, o 0 si c no es alfabético.
int c = getah()
if(isalpha©) printf(“%c es letra\n”, c);
Funciones relacionadas: iascii.
isascii
#include ctype.h>
iscntrl Carácter de control. 0..1Fh, 7Fh
isdigit Dígito decimal. ´0´..´9´
isgraph Carácter imprimible (sin espacio). 21h a 7Eh
islower Carácter minúscula. ´a´..´z´´
isprint Carácter imprimible 20h..7Eh
ispunct Carácter puntuación 21h..2Fh, 3Ah..40h,
5Bh..60h, 7Bh..7Eh
isspace Carácter blanco. 9h..Dh 0 20h (blanco)
isupper Carácter mayúscula. ´A´..´Z´
isxdigit Dígito hexadecimal. ´0´..´9´
´A´..´F´
´a´.. f´
int isascii(int c);
Comprueba si un carácter c es un carácter ASCII; c está en el rango 0-127.
Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII.
carac = getch();
if(isascii(carac))
printf(“%c es ASCII \n”, carac);
else
printf(“%c no es ASCII \n”, carac);
Funciones relacionadas: toascii, isalnum, isdigit,
Cada macro (función) devuelve un valor distinto de cero si c satisface
el criterio de esa macro; en caso contrario, devuelve un cero.
if(isprint(c)) printf(“\n %c imprimible\n”, c);
if(iscntrl(c)) printf(“%c es un carácter de control\”, c);
if(isdigit(c)) printf(“%c es un dígito\n”, c);
if(islower(c)) printf(“%c es letra minúscula\n”, c)
Funciones relacionadas: iascii.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 627
toascii
#include
F.6.
FUNCIONES DE CALENDARIO (FECHA Y HORA)
int toascii(int c);
Esta función convierte un valor entero en un carácter ASCII válido.
C = toascii(entero);
Las funciones de calendario (fecha y hora) permiten obtener la hora actual
y, a continuación, convertirla y almacenarla de acuerdo a sus necesidades
particulares. La hora actual se toma siempre de la hora del sistema. Las funciones
de calendario están incluidas en el archivo de cabecera time.h.
Funciones relacionadas: iascii.
asctime
#include
_tolower
tolower
int _tolower(int c);
int tolower(int c);
#include
Convierte un carácter mayúscula en minúscula. Utilice _tolower sólo
cuando esté seguro de que el carácter que quiere convertir es una letra
mayúscula.
La función _tolower() sólo está disponible en sistemas UNIX. Por
consiguiente, para asegurar la compatibilidad utilice sólo la función tolower().
c = tolower(´S´);
// c se convierte en ´S´
Funciones relacionadas: iascii, _toupper, toupper.
char *asctime(const struct tm *hora);
Convierte la fecha y la hora almacenada en una estructura de tipo tm en
una cadena de caracteres. La estructura tm se define en time.h así:
struct tm
{
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
};
// [0,59], segundos
// [0,59], minutos
// [0,23], horas
// [1,31], dias del mes
// [0,11], mes del año
// [desde 1900], año
// [0,6], dias desde domingo
// [0,265], numero dia año
// indicador hora de verano
printf(“Fecha/hora es %s\n”, asctime(&reloj));
_toupper
touper
#include
Funciones relacionadas:
time.
ctime, gmtime, clocaltime, strftime,
int _toupper(int c);
int _toupper(int c);
int c; // carácter a convertir
Estas funciones convierten un carácter minúscula en mayúscula. Utilice
_toupper sólo cuando esté seguro de que el carácter que quiere convertir
es una letra minúscula (rango a-z).
La macro _toupper no está disponible en ANSI C. Para asegurar la
compatibilidad, utilice siempre toupper().
c = toupper(´S´);
// c se convierte en ´S´
Funciones relacionadas: iascii, _tolower, tolower.
clock
cock_t clock(void);
#include
Calcula el tiempo empleado por el proceso llamador, es decir, el tiempo
utilizado de procesador. Devuelve un valor en ticks que ha de dividirse
por la constante CLK_TCK para obtener el tiempo transcurrido en segundos.
clock_t inicio, fin;
printf(“Inicio:%f\n, clock()/CLK_TCK;
Funciones relacionadas: gettime, time.

628 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
ctime
#include
ftime
#include
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
cadena de caracteres (mes día hora año\0).
Obtiene la hora actual y la almacena en la estructura timeb apuntada
por ptrhora.
time_t hora;
hora = time(NULL);
printf(“Hora actual=%s\n”, ctime(&hora));
Funciones relacionadas: asctime, ftime, strtime, time.
struct timeb {
long time;
short millitm;
short timezone;
short dstflag;
};
// segundos desde 00:00:00 hora GMT
// milisegundos
// diferencia en minutos
// hora Greenwich y hora local
// hora de verano, ahorro de luz
difftime
#include
double difftime(time_t hora2, time_t hora1);
Obtiene la diferencia entre dos tiempos en segundos.
ftime(&hora);
Funciones relacionadas: time tzset.
getdate
#include
time_t inicio, fin
clrscrl();
inicio = time(NULL);
delay (5000);
fin = time(NULL);
printf(“Diferencia en segundos: %f\n”,
difftime(inicio, fin));
Funciones relacionadas:
tzset.
asctime, ctime, gmtime, localtime,
void getdate(struct date *f);
Obtiene la fecha del sistema. Los componentes se almacenan en la
estructura date definida en dos.h.
struct date {
int da_year; // año actual (1980-2099)
char da_day; // dia mes (1-31)
char da_mon; // mes (1-12)
};
dostounix
#include
struct date fecha;
getdate(&fecha);
long dostounix(struct date *f, struct time *h);
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en
formato UNIX.
time_t t;
struct time dos_hora;
struct date dos_fecha;
gatdate(&Dos_hora);
gettime(&dos_fecha);
t = dostounix(&dos_fecha, &dos_hora);
Funciones relacionadas: ctime, gatdate, gettime.
Funciones relacionadas: dostounix, gettime, setdate, settime.
gettime
void gettime(struct time *t);
#include
Obtiene la hora actual del sistema. Los componentes de la hora se almacenan
en la estructura time definida en dos.h.
struct time {
unsigned char ti_min // minutos (0-59)

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 629
unsigned char ti_hour // horas (0-23)
unsigned char ti_hund // centésimas de segundo (0-99)
unsigned char ti_sec // segundos (0-59)
};
setdate
void setdate(struct date *f);
#include
struct time hora;
gettime(&hora);
Funciones relacionadas: dostounix, getdate, setdate, settime.
gmtime
struct tm *gmtime (const time_t *hora);
#include
Convierte la fecha y hora en el tiempo medio de Greenwich (GMT)
(año, mes, día, hora, minutos, segundos y otros campos). Véase struct tm
en asctime.
Cambia la fecha actual del sistema. Los componentes de la fecha (día,
mes. Año) se especifican en los campos de la estructura date.
struct date {
int da_year; // año actual
char da_day; // día mes
char da_mon; // mes, 1 para enero, 2...
};
En Visual C++ la función equivalente es _dos_setdate.
setdate(&fecha);
Funciones relacionadas: getdate, gettime, settime, dostounix.
ahora = gmtime(&hoy);
Funciones relacionadas: asctime, ctime, ftime, localtime, time.
settime
void settime(struct time *h);
#include
localtime
struct tm *localtime(const time_t *hora);
#include
Convierte una fecha y hora en varios campos de una estructura de tipo
tm. Véase struct tm en asctime.
Cambia la hora actual del sistema. Los componentes de la hora —hora,
minutos y segundos— se deben cargar en los campos apropiados de la
estructura time definida en dos.h. Véase gettime.
settime(&hora);
Funciones relacionadas: dostounix, gatdate, gettime, setdate.
tiempoactual = localtime(&ahora);
Funciones relacionadas: asctime, gmtime, time.
stime
int stime(time_t *t);
#include
mktime
time_t mktime(struct tm *h);
#include
Convierte la hora local a un valor de calendario. Véase struct tm en
asctime.
Funciones relacionadas: asctime, gmtime, localtime, time.
Establece la fecha y hora del sistema al valor contenido en la posición
cuya dirección está en el argumento t.
time_t horasis;
horasis = time(NULL);
stime(&horasis);
printf(“segundos desde 1/1/70 %ld”, horasis);
Funciones relacionadas: dostounix.

630 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
strftime
#include
Convierte a formato DOS un valor de hora en el formato UNIX.
size_t strftime(char *cad, size_t maxlon,
const char *formato, const struct tm *t);
Convierte un puntero en una estructura tm en una cadena cad (con una
longitud máxima de n), utilizando f para dar formato a la cadena. El formato
es similar a printf().
horaseg = time(NULL);
horaactual = localtime(&horaseg);
strftime(buffer, 80, “%A %B %d 19%y:I:%M, horaactual);
Funciones relacionadas:
time.
time
time_t time(time_t *h);
asctime, ctime, gmtime, localtime,
#include
Proporciona el tiempo del sistema en segundos desde las 00:00:00 de
1/1/1970 tiempo GMT.
time(&hora);
tzset
void tzset(void);
#include
Establece las variables de entorno horarios TZ; asigna valores a las
variables globales timezone, daylight y tzname.
tzset();
printf(“Luz de verano = %d\n”, daylight);
printf(“zona horario = %ld\n”, timezone);
Funciones relacionadas:
time.
unixtodos
asctime, ftime, gmtime, localtime,
#include
void unixtodos(long time, struct date *f, struct time *h);
tnixtodos(t_unix, &d_dos, ft_dos);
Funciones relacionadas: getdate, gettime, time, setdate, settime.
F.7.
FUNCIONES DE CONTROL DE DIRECTORIOS
MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerárquico que
permite al usuario organizar sus archivos en directorios y subdirectorios.
Las funciones de control de directorios en Borland C++ proporcionan las
herramientas necesarias para crear, modificar, mover y eliminar directorios
desde sus programas C. Las funciones de manipulación de directorios residen
en el archivo de cabecera dir.h.
chdir
int chdir(const char *camino);
#include
Cambia el directorio de trabajo actual al directorio especificado en el
argumento camino. La función devuelve un 0 si tiene éxito; en caso contrario,
devuelve un valor de –1 para asignar el error. Cuando se produce un
error, la variable global errno toma el valor ENOENT (camino o archivo no
encontrado).
if(chdir(\\)) {
perror(“chdir()”);
exit(1);
}
Funciones relacionadas: mkdir, rmdir, setdisk, system.
findfirst
#include
int findfirst(const char *camino, struct ffblk *ffblk, int atrib);
Busca en un directorio de disco hasta encontrar el primer archivo cuyo
nombre y atributos se corresponden con los valores especificados. El formato
de la estructura ffblk es:
struct ffblk {
char ff_reserved[21];
// reservada por DOS

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 631
char ff_atrib;
int ff_ftime;
int ff_date;
long ff_fsize;
char ff_name[13];
};
// encontrado atributo
// hora archivo
// fecha archivo
// tamaño archivo
// encontrado nombre de archivo
La variable attrib viene definida en el archivo de cabecera y
puede ser igual a uno de estos valores:
FA_RDONLY
FA_HIDDEN
FA_SYSTEM
FA_LABEL
FA_DIREC
FA_ARCH
struct ffblk ffblk;
int t;
t = findfirst(“*.*”, &ffblk,0);
Funciones relacionadas: findnext.
findnext
Archivo de sólo lectura.
Archivo oculto.
Archivo del sistema.
Etiqueta de volumen.
Directorio.
Bit de archivo activado.
int findnext(struct ffblk *ffblk);
#include
findnext continúa la búsqueda de findfirst(). findnext llama a
la función 4Fh de DOS para encontrar el siguiente archivo cuyo nombre y
atributos son idénticos a los dados en la llamada a la función findfirst().
fnsplit
#include
void fnsplit(const char *camino, char *u, char *dir,
char *nombrearch, char *ext);
Separa un nombre de camino completo en sus componentes: letra de la
unidad (u), camino del directorio, nombre del archivo y extensión del archivo
(ext).
h = fnsplit(camino, unidad, dir, nomarch, ext);
Funciones relacionadas: fnmerge.
getcurdir
int getcurdir(int u, char *dir);
#include
Obtiene el directorio de trabajo actual en una unidad específica. El
número de la unidad (u) 0 indica la unidad actual por omisión, 1 significa
unidad A, 2 unidad B, etc. La función devuelve un cero si tiene éxito, en
caso de error devuelve –1.
getcurdir(3, cuentas);
Funciones relacionadas: getcwd, getdisk.
findnext(&filefinfo);
Funciones relacionadas: findfirst.
getcwd
char *getcwd(char *camino, int numcar);
#include
fnmerge
#include
void fnmerge(char *camino, const char *u, const char *dir,
const *nombrearch, const char *ext);
Crea un nombre de camino completo compuesto de una letra de la unidad
(u), camino del directorio (dir), nombre de archivo (nombrearch) y
extensión del archivo (ext).
fnmerge(camino, “c:”, \\aux\\”,”demo”,”.dat”);
Funciones relacionadas: fnsplit.
getcwd obtiene el nombre de camino completo del directorio de trabajo
actual, incluyendo el nombre de la unidad. El argumento numcar indica
a getcwd el máximo número de caracteres que el buffer camino puede contener.
La función getcwd es útil para obtener el nombre del directorio actual
y guardarlo. Si su programa cambia los directorios de trabajo durante su ejecución,
puede utilizar el nombre guardado para restaurar el directorio de trabajo
actual antes de terminar.
getcwd(cuentas, 80)
Funciones relacionadas: chdir.

632 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
getdisk
#include
Funciones relacionadas: chdir, rmdir.
int getdisk(void);
La función getdisk obtiene el valor entero que representa la unidad
actual (0, unidad A; 1, unidad B...)
int unidad;
clscr();
unidad = getdisk();
Funciones relacionadas: setdisk.
mktemp
#include
char *mktemp(char *plantilla);
Crea un nombre de archivo a partir de una plantilla. Devuelve un puntero
al nombre del archivo si tiene éxito y nulo en caso de error.
mktemp(nombre);
mdir
#include
searchpath
#include
int rmdir(const char *camino);
Elimina el directorio escrito por la variable camino, siempre que el
directorio esté vacío, no sea el directorio raíz y no sea el directorio de trabajo
rmdir(); devuelve 0 si la operación de borrado tiene éxito; si se produce
un error, el valor devuelto es –1 y la variable global errno se fija a uno
de los siguientes valores:
EACCES Permiso denegado.
ENOENT Camino archivo no encontrado.
Esta función es similar a RMDIR o RD de MS-DOS.
rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS
Funciones relacionadas: chdir, mkdir.
char searchpath(const char *nombre);
Busca un archivo específico en una lista de directorios, incluyendo el
directorio de trabajo actual y los definidos en la variable de entorno PATH.
Si el archivo se encuentra, se devuelve un puntero al nombre del camino del
archivo; en caso contrario, se devuelve NULL.
buffer = searchpath(“BC.EXE”);
Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la
variable de entorno PATH.
buffer = searchpath(“autoexec.bat”);
Funciones relacionadas: getenv, putenv.
mkdir
#include
setdisk
#include
int mkdir(const char *camino);
Crea un directorio con un nombre de camino especificado. Funciona
igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha
creado con éxito o –1 si se produce un error; en este caso, la variable global
errno toma el valor EACCES (permiso denegado) o ENOENT (nombre de
camino no válido).
EACCES
ENOENT
Permiso denegado.
Camino no encontrado.
resultado = mkdir(“PRUEBAS”);
// crea el directorio PRUEBAS
int setdisk(int unidad);
Cambia a una nueva unidad por omisión. El valor de la unidad (unidad)
es un entero.
Unidad A
B:
C:
D:
...
nuevaunidad = setdisk(3); / nueva unidad actual es C:
Funciones relacionadas: getdisk

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 633
F.8.
FUNCIONES DE CONTROL DE PROCESOS
atexit
#include
Un proceso es un programa ejecutable en memoria y su entorno asociado.
Cada vez que se ejecuta un programa se crea un proceso.
En resumen, un proceso es un programa que se está ejecutando por el
sistema operativo. Consta del código del programa y de datos, además de
información relativa al proceso, tales como número de archivos abiertos.
Siempre que se ejecuta un programa al nivel del sistema operativo se arranca
un proceso.
Las funciones de control de proceso permiten arrancar, detener y gestionar
procesos desde dentro de un programa. La mayoría de las funciones
de control se declaran en el archivo de cabecera process.h; otros archivos
de cabecera que contienen funciones de control de proceso y del entorno son
locale.h, signal.h, setjmp.h y stdlib.h.
abort
void abort(void);
#include
#include
Termina la ejecución del programa actual y devuelve un código de
error (3).
if (argc 1) {
printf(“Faltan argumentos!\n”)
abort()
}
Funciones relacionadas : exit, _exit, raise, signal, spaw.
int atexit(void(*func)(void));
Procesa la función especificada al salir.
atexit(segundo);
Funciones relacionadas: abort, exit, _exit.
exec(familia)
#include
int excel(char *camino, char *arg0,...,NULL);
int execle(char *camino, char *arg0,..., *argn, NULL, char **env);
int execlp(char *camino, char *arg0, arg1,...,NULL);
int execlpe(char *camino, char *arg0,...argn, NULL, char **env);
int execv(char *camino, char argv[]);
int execve(char *camino, char argv[], char **env);
int execvp(char *camino, char *argv[]);
int execvpe(char *camino, char *argv[], char **env);
Cargan y ejecutan un proceso hijo en la memoria actualmente ocupada
por su código del programa. Las funciones exec crean un proceso hijo que
carga y ejecuta el programa especificado por el argumento camino.
execlo(“hijo.exe”, hijo.exe”, “Uno, “Dos”, NULL);
execv(“hijo.exe”, argv);
assert
#include
Funciones relacionadas: abort, atexit, exit, _exit, fpreset, spawn.
void assert(int expresión);
Imprime un mensaje de error e interrumpe el programa si expresión es
falsa (0).
assert(string != NULL;
assert(*string != ´\0´);
assert(strlen(string) < 2);
Funciones relacionadas: abort, raise, signal.
exit
void exit(int estado);
#include
Termina un programa. Antes de terminar, se cierran todos los archivos,
se escribe la salida a través del buffer y se llama a cualquier función exit
registrada. estado representa el estado de salida del programa; 0, salida
normal; distinto de cero, indica un error.
exit(0);

634 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
Funciones relacionadas: abort, atexit, ´exit, exit, ´fpreset,
spawn, system.
Obtiene información detallada sobre formatos monetarios y numéricos
de diferentes países.
_exit
void _exit(int estado);
#include
p_lconv = localeconv();
Funciones relacionadas: setlocale.
Termina inmediatamente el proceso actual sin hacer otras operaciones
auxiliares (como cierre de archivos).
_exit(0)
Funciones relacionadas: exit.
getenv
char *getenv(const char *nomvar);
#include
Obtiene la definición de una variable de la tabla de entorno del proceso.
Utiliza la variable global environ para localizar la lista de las variables
de entorno y, a continuación, busca una entrada en la lista correspondiente
a nomvar.
varlib = getenv(“LIB”);
Funciones relacionadas: putenv.
longjmp
void longjmp(jmp_buf env, int valor);
#include
Restaura el estado de la pila y la ejecución local anteriormente grabada
en env por setjmp.
longjmp(plaza, 3);
Funciones relacionadas: setjmp.
perror
void perror(const char *cadena);
#include
Imprime un mensaje de error del sistema en el flujo stderr. El argumento
cadena se imprime primero, seguido por dos puntos; a continuación,
el mensaje de error correspondiente al valor actual de la variable global
errno y, finalmente, un carácter de nueva línea. Si cadena es un puntero
nulo o un puntero a una cadena nula, perror imprime sólo el mensaje de
error del sistema.
getpid
unsigned getpid(void)
#include
perror(“Error de cierre de archivos”);
Funciones relacionadas: _strerror, strerror.
Obtiene el ID de proceso de un programa. Está disponible en sistemas
UNIX.
printf(“PID:%X\n”,getpid());
putenv
int putenv(const char *cadena);
#include
Funciones relacionadas: getpsp.
localeconv
struct lconv *localeconv(void);
#include
Crea nuevas variables de entorno o modifica los valores de las variables
de entorno existentes.
if(putenv(argv[1] == -1)
Funciones relacionadas: getenv.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 635
raise
int raise(int señal);
#include
Envía una señal al programa en ejecución. Crea una condición de
excepción correspondiente al número señal. Existen diferentes constantes,
por ejemplo, SIGABRT (terminación anormal).
printf(“prueba de raise\n”);
raise(SIGABRT);
Funciones relacionadas: abort, signal.
setjmp
int setjmp(jmp_buf env);
#include
Guarda el estado actual del programa (el entorno de la pila) antes de llamar
a otra función. Este entorno puede ser restaurado por una llamada a
longjmp, realizando el efecto de un goto no local.
if(setjmp(env) != 0) printf(“valor de longjmp\n”);
Funciones relacionadas: longjmp.
int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL,
char **envp[]);
int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL);
int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL,
char **envp[]);
int spawnv(int modo, char *camino, char *argv[]);
int spawnve(int modo, char *camino, char /argv[], char *envp[]);
int spawnvp(int modo, char *camino, char *argv[]);
int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);
La familia de funciones spawn crea y ejecuta un nuevo proceso hijo.
Debe haber memoria suficiente para cargar y ejecutar el proceso hijo.
spawnlpe(P_WAIT, “hijo.exe”, “hijo.exe”, “spawnlpe”, buf,
NULL, env);
Funciones relacionadas: exec.
F.9.
FUNCIONES DE CONVERSIÓN DE DATOS
Las funciones de conversión de tipos de datos sirven para crear un puente de
unión entre los dos estilos de representación de números: la cadena de texto
legible por los humanos y el formato binario legible por las máquinas. Las
funciones de conversión son ideales para convertir argumentos de líneas de
órdenes de su representación de cadena al formato interno.
signal
void (*signal(int sig, void (*func) (int))) (int);
#include
atof()
#include
#include
Establece tratamiento de señales de interrupción. La función signal permite
a un proceso elegir uno de los diferentes modos de manipular una señal
de interrupción del sistema operativo.
signal(SIGINT, SIG_IGN);
Funciones relacionadas: abort, _control87, exit, longjmp, raise,
setjmp.
spawn (funciones)
#include
#include
int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);
double atof(const char *cadena);
La función atof() convierte el argumento cadena en un valor de doble
precisión. La cadena debe tener el siguiente formato:
[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]
opcional
blancos o
tabulaciones
dígitos decimales
e/E
La conversión termina cuando aparece el primer carácter no reconocible
o cuando se encuentra un carácter nulo (´\0´).

636 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
double x;
char *cad_dbl = “200-85”;
...
x = atof(cad_dbl); // convierte la cadena “200.85”
a real
Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf,
strtod.
La conversión de caracteres de la cadena hasta que se encuentre el primer
carácter no reconocible o el carácter nulo (‘\0’).
long int i;
char cad_ent = “9876543”;
...
i = atol(cad_ent);
// convierte cadena “9876543” a entero
// largo.
atoi
int atoi (const char *cadena)
#include
Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod,
strtol, strtoul, ultoa.
La función atoi() convierte el argumento cadena en un valor entero.
La cadena debe tener el siguiente formato:
[espacio en blanco][signo][ddd]
espacio o tabulación
opcional
dígitos decimales
La conversión termina cuando se encuentra un carácter no reconocible
(carácter nulo, ‘\0’, punto decimal o una letra). Si no puede convertir la
cadena devuelve nulo.
int i;
char *cad_ent =123;
...
i = atoi(cad_ent);// convierte la cadena “123” al entero 123
Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.
atol
long atol(const char *cadena);
#include
Convierte el argumento cadena en un valor entero largo. La cadena debe
tener el formato:
[espacio en blanco][signo][ddd]
blancos y tabulaciones
opcional
dígitos decimales
ecvt
#include
char *ecvt(double valor, int n, int *dec, int *signo);
La función ecvt() convierte un argumento de valor doble precisión en
una cadena con n dígitos. Si valor tiene más de n dígitos, los dígitos inferiores
se truncan. dec es un puntero a un entero en donde se devuelve la
posición del punto decimal; signo es un puntero a un entero donde se
devuelve el signo (cero, positivo; en los restantes casos, negativo).
p_buffer = ecvt(valor, exactitud, &dec, &signo);
Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa,
ltoa, ultoa.
fcvt
#include
char *fcvt(double valor, int n, int *dec, int *signo);
Al igual que la función ecvt, fcvt convierte el argumento valor de
doble precisión en una cadena de n dígitos. Si el número de dígitos de valor
excede a n, el exceso de dígitos se trunca. Si hay menos dígitos que n la
cadena se rellena con ceros. fcvt se diferencia de ecvt en el modo de tratar
los dígitos significativos. ecvt() busca un número total de dígitos,
mientras que fcvt() busca el número de dígitos a la derecha del puntero
decimal.
cadena = fcvt(valor, exactitud, %oposición_d, &signo);
Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,
sprintf, ultoa.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 637
gcvt
#include
strtod
#include stdlib.h>
char *gcvt(double valor, int ndig, char, *buf);
La función gcvt() convierte el argumento valor de doble precisión en
una cadena de caracteres que se almacena en el buffer cuya dirección se da
en el argumento buf. Se debe asignar bastante espacio en el buffer para contener
todos los dígitos de la cadena convertida y el carácter nulo de terminación
(‘\0’).
gcvt(valor, digitos, cadena);
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf,
sprintf, ultoa.
itoa
char *itoa(int valor, char *cad, int base);
#include stdlib.h>
La función itoa() convierte el argumento entero valor en una cadena
de caracteres utilizando el argumento base, como base de un sistema de
numeración (2 a 36). Debe existir bastante espacio en cad para contener 17
caracteres, itoa() devuelve un puntero a la cadena cad.
itoa(32, buffer, 16); // buffer contendrá “20”, ya que 32 entero
// equivale a 20 en hexadecimal
Funciones relacionadas: atoi, atol, itoa, ultoa.
double strtod(const char *cad, char **p);
La función strtod() convierte la cadena cad en un valor de doble
precisión. La cadena debe tener el formato
[blanco][signo][ddd][.][exponente][signo][ddd]
blanco/
tabulación
+, - d, D, e, E
dígitos decimales
strtod() devuelve el valor de doble precisión y cero si no se produce la
conversión. La conversión se termina con el primer carácter no reconocible.
Aplicación: Convertir la cadena “843899.567” a un valor de coma flotante
double.
#include
#include
main()
{
double x;
char *num_flt = “843899.567”:
char *p;
x = strtod(num_flt, &p);
printf(“x = %f\n”,x);
}
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.
ltoa
char *ltoa(long valor, char * cad, int base);
#include
La función ltoa() convierte el argumento entero largo valor en una
cadena de caracteres que utiliza el argumento base como base de un sistema
de numeración. Como un entero largo ocupa 32 bits en base 2, la cadena
puede ocupar 33 bytes con el carácter nulo de terminación. Debe haber
bastante espacio para contener 33 bytes. ltoa() devuelve un puntero a cad.
long valor = 99288377L
ltoa(valor, cadena, 30);
Funciones relacionadas: atoi, atol, itoa, ultoa.
strtol
long strtol(const char *cad, char **p, int b);
#include
La función strtol() convierte una cadena cad en un valor entero largo.
La cadena (puede contener hasta 33 caracteres) debe tener el formato:
[espacio en blanco][signo][0][x|X][ddd]
+, - dígitos decimales
hexadecimal
blancos y tabulaciones octal

638 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
La conversión se termina con el primer carácter no reconocible. Si se
produce un error de desbordamiento (positivo o negativo) la variable errno
se establece al valor de la macro ERANGE.
Aplicación. Convertir la cadena “9876” en valor entero.
#include
#include
main()
{
int base = 10;
long int i;
char *cad_ent = “9876”;
char *ptrcad;
i = strtol(cad_ent, &ptrcad, base);
printf(“i = %ld\n”, i);
}
Funciones relacionadas: atoi, atof, atol, ltoa, strtoul.
strtoul
#include
unsigned long strtoul(const char *cad, char **p, int base);
Convierte una cadena de caracteres a un entero largo sin signo en la
base dada. La cadena debe tener el formato:
[espacio en blanco][0][x|X][ddd]
octal
blanco o tabulaciones
dígitos decimales
hexadecimal
Si la base b es cero, strtoul utiliza el primer carácter de la cadena para
determinar la base del valor.
La cadena cad puede contener hasta 33 caracteres, excluyendo el carácter
de terminación nulo (´\0,). Si se produce un error de desbordamiento,
la variable errno se pone al valor de ERANTE.
i = strtoul(cad_ent, &ptrfin, base);
Funciones relacionadas: atol, ultoa, strtol.
ultoa
#include
char *ultoa(unsigned long valor, char *cad, int base);
La función ultoa() toma valor en base b (entre 2 y 36) y lo convierte
en una cadena. Devuelve el puntero al principio de cad. No devuelve código
de error. cad puede contener hasta 33 caracteres, excluyendo el carácter
de terminación nulo (´\0´).
ultoa(valor, buffer, base);
Funciones relacionadas: itoa, ltoa.
F.10.
FUNCIONES DE ENTRADA/SALIDA
Las funciones de E/S (Entrada/Salida, I/O, Input/Output) permiten leer y
escribir datos entre archivos y dispositivos. En C no hay estructuras de
archivos predefinidas, todos los datos se tratan como secuencias de bytes.
La lista de funciones de E/S se han agrupado de acuerdo a las tareas específicas
que realizan:
1. Secuencias o flujos (stream).
2. Bajo nivel.
3. Consola y puertos.
Funciones de flujos (stream)
Las funciones de E/S tratan los datos como una secuencia o flujo de caracteres
individuales. La elección adecuada de las funciones disponibles permite
procesar datos en tamaños y formatos diferentes, desde caracteres independientes
a estructuras de datos complejos. La E/S por secuencia, o flujo,
también proporciona acciones de taponamiento (buffering) que mejoran significativamente
el rendimiento. Para utilizar los flujos, generalmente se
debe incluir el archivo stdio.h.
clearerr
void clearerr(FILE *f);
Reinicializa el indicador de error de un flujo f.
clearerr(fichen);
Funciones relacionadas: eof, feof, ferror, perror.
#include

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 639
fclose, fcloseall
#include
fflush
#include
int fclose(FILE *f);
int fcloseall(void);
Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall)
excepto stdin, stdout y stderr. Se devuelve el número de flujos cerrados
y EOF si se produce un error.
fcloseall();
Funciones relacionadas: close, fdopen, fopen.
int fflush(FILE *f);
Limpia (vacía) un flujo. Los buffers se limpian automáticamente cuando
están llenos, cuando se cierra el flujo, o cuando un programa termina normalmente
sin cerrar el flujo.
fflush(fp);
Funciones relacionadas: fclose, flshall, fopen.
fdopen
FILE *fdopen(int handle, char *modo);
#include
Abre un flujo utilizando un handle (entero devuelto por las rutinas de
E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una
estructura de datos FILE con el archivo especificado por handle.
p_datos = fdopen(handle, “rb”);
Funciones relacionadas: fclose, fopen, fropen, open.
fgetc
int fgetc(FILE * f);
#include
Lee un carácter de la posición actual del archivo y, a continuación,
incrementa esta posición.
c = fgetc(fp)
Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc,
putchar.
feof
#include
fgetchar
#include
int feof(FILE *flujo);
#int fgetchar(void);
Comprueba el final de archivo de un flujo.
feof(fichen);
Funciones relacionadas: clearerr, fclose, rewind.
Lee un carácter del archivo stdin, normalmente el teclado.
c = fgetchar();
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.
ferror
#include
int ferror(FILE *f);
Verifica si se ha producido un error en un flujo f.
ferror(fichen);
Funciones relacionadas: clarerr, eof, feof, fopen, perror.
fgetpos
int fgetpos(FILE *flujo, fpos_t *p);
#include
Obtiene y graba la posición actual del archivo. fos_t es un tipo definido
en stdio.h.
fgetpos(fp, &pos_archivo);

640 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
fgets
char *fgets(char *cad, int n, FILE *f);
#include
Lee una cadena de un flujo (hasta que se encuentra \n, o el número
máximo de caracteres especificados).
if ((corriente2 = fopen(“datos”, “W+”)) == NULL
printf(“el archivo..no se ha abierto \n”);
Funciones relacionadas: fclose, fcloseall, fdopen, ferror,
fileno, freopen, open, setmode.
fgets(caddemo,80, fp);
Funciones relacionadas: fputs, gets, puts.
flushall
int flushall(void);
#include stdio.h>
fileno
int fileno(FILE *f);
#include
Obtiene el mando o manejador (handle) del archivo asociado con un
flujo.
fileno(stdin);
Funciones relacionadas: fdopen, fopen.
Vacía (limpia) todos los buffers asociados con los archivos abiertos.
numvaciados = flushall();
Funciones relacionadas: fclose, fflush.
fprintf
#include
int fprintf(FILE *f, const char *formato[arg,...]);
Imprime datos con formato en un flujo.
fopen
#include
fprintf(f1,”El resultado es %f\n”,result);
FILE *fopen(const char *f, const char *modo);
Abre un archivo f. La cadena de caracteres modo especifica el tipo de
acceso.
Modo
“r”
“w”
“a”
“r+”
“w+”
“a+”
“rb”
“wb”
“ab”
“rb”
“wb”
“ab”
Acción
Abre para lectura.
Abre un archivo vacío para escritura.
Abre para escritura al final del archivo (añadir).
Abre para lectura/escritura.
Abre un archivo vacío para lectura/escritura.
Abre para lectura y añadir.
Abre un archivo binario para lectura.
Crea un archivo binario para escritura.
Abre un archivo binario para añadir.
Abre un archivo binario para lectura/escritura.
Crea un archivo binario para la lectura/escritura.
Abre o crea un archivo binario para lectura/escritura.
Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
fputc
int fputc(int c, FILE *f);
#include
Escribe un carácter c en el flujo abierto para salida con buffer.
fputc(*(p++), stdout);
Funciones relacionadas: fgetc, fgetchar, fputchar, getc, getchar,
putc.
fputchar
int fputchar(int c);
#include

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 641
Escribe el carácter c en stdout.
fputchar(´q´);
Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.
Lee datos con formato de un flujo.
fscanf(flujo, “%s%f”, cad, &f);
Funciones relacionadas: csanf, fprintf, scanf, sscanf.
fputs
#include
fseek
#include
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 impreso,
si hay error devuelve EOF.
Mueve el puntero del archivo asociado con f a una nueva posición que
está desplazada desp bytes de org.
fputs(“esto es una prueba”, f1);
Origen
Significado
Funciones relacionadas fgets, gets, puts.
fread
#include
size_t fread(void *p, size_t t, size_t n, FILE *f);
Lee n registros de t bytes en la memoria apuntada por p desde el flujo f.
SEEK_SET
Principio de archivo.
SEEK_CUR
Posición actual puntero archivo.
SEK_END
Final de archivo.
fseek(f1,OL,SEEK_SET); // ir al principio
Funciones relacionadas: ftell, rewind, fopen.
fread(buf, strlen(msg)+1, 1, flujo);
Funciones relacionadas: fwrite, read.
fsetpos
int fsetpos(FILE *f, const fpos_t *p);
#include
freopen
#include
FILE *freopen(const char *f, const char *m, FILE *flujo);
Cierra el archivo asociado con flujo y reasigna flujo al archivo especificado
por f. Los modos (m) utilizados son los mismos de fopen.
freopen(“salida.txt”, “w”, stdout);
Funciones relacionadas: fclose, fopen.
Establece la posición del puntero del archivo al lugar especificado por
el objeto apuntado por p.
fsetpos(fp, &posarch);
Funciones relacionadas: getpos.
ftell
#include
long int ftell(FILE *f);
Obtiene la posición actual (puntero) del archivo asociado con el flujo f.
fscanf
#include
ftell(fichen);
int fscanf(FILE *f, const char *formato [, dirección,...]);
Funciones relacionadas: fgetpos, fssek, tell.

642 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
fwrite
#include
size_t fwrite(const void *p, size_t l, size_t n, FILE *f);
Escribe n elementos (registros) de longitud l desde la memoria apuntada
por p al archivo f. Devuelve el número de caracteres realmente escritos
que, si la función tiene éxito, es igual al número indicado.
num = fwrite(lista, sizeof(char),25,flujo);
Devuelve el siguiente carácter de stdin. Si se alcanza el final de archivo,
se devuelve EOF.
int c;
while((c = getchar())!= ´\n´)
printf(“%c”, c);
Funciones relacionadas: fgetc, fgetchar, getch, getche, putc,
putchar, ungetc.
Funciones relacionadas: fread, fscanf, getc, fgetc.
getche
#include
getc
#include
int getche(void);
int getc(FILE *f);
Devuelve el siguiente carácter de un flujo de entrada dado e incrementa
la posición actual del puntero del archivo. Si se alcanza el final de archivo,
se devuelve EOF.
whilec(c = getc(fx)!= EOF) {
printf(“%c”, c);
}
Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc,
putchar, fopen.
getch
int getch(void)
Lee un carácter del teclado sin hacer eco en la pantalla.
do {
car = getch();
char = toupper(car);
} while(car != ´S´);
#include
Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.
Lee un carácter del teclado haciendo eco del carácter en la pantalla.
resp= getche();
Funciones relacionadas: cgets, getch, getchar, ungetch.
gets
char *gets(char *cad);
#include
Lee una línea desde el archivo de entrada estándar stdin, por omisión
es el teclado y lo guarda en cad.
gets(nombre);
Funciones relacionadas: fgets, fputs, puts.
getw
int getw(FILE *f);
Lee un entero (o una palabra de dos bytes) de un flujo f.
#include
getchar
int getchar(void);
#include
suma = getw(fx) + suma;
Funciones relacionadas: fread, putw.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 643
printf
#include
puts
#include
int printf(const char *formato[,argumento,...]);
Escribe cadenas de caracteres y valores de variables, con formato, en el
archivo de salida estándar stdout (por omisión, la pantalla).
int puts(const char *cad);
Escribe una cadena en el archivo de salida estándar stdout.
puts(“Desea continuar(s/n?”);
Código
Formato
Funciones relacionadas: fgets, fputs, gets.
%c Carácter.
%d Entero decimal.
%e Real (double o float), notación científica.
%f Coma flotante.
%s Cadena de caracteres.
%x Hexadecimal sin signo.
printf(“producto %d y %d es %d\n”,x,y, x*y);
Funciones relacionadas:
vprintf, vsprintf.
fprintf, scanf, sprintf, viprintf,
putw
int putw(int i, FILE *f);
Escribe un entero en un flujo f.
putw(100, fx);
Funciones relacionadas: getw, printf.
rewind
void rewind(FILE *f);
#include
#include
putc, putchar
#include
Reinicializa el puntero del archivo al principio de un flujo.
int putc(int c, FILE *f);
int putchar(int c);
Escribe un carácter en un flujo (putc) o en stdout (putchar).
putc(´*´, demo);
Funciones relacionadas: fputc, fputchar, getc, getchar.
rewind(fx);
Funciones relacionadas: fseek.
scanf
#include
int scanf(const char *formato[,dirección,...]);
Lee datos con formato del flujo de entrada estándar.
putch
int putch(int c);
Escribe un carácter en la pantalla.
putch(´B´);
Funciones relacionadas: putc, putchar.
#include
Código
Formato
%c Carácter.
%d Entero decimal.
%x Hexadecimal.
%i Entero decimal.
%f Número real.
%o Octal.
%p Puntero.
%s Cadena.

644 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
scanf(“%d %f %c %s”, &i, &fp, &c, s);
Funciones relacionadas: fscanf, printf, sscanf, vfprintf,
vprintf, vsprintf
Esta función es idéntica a scanf, excepto que los datos son leídos del
array apuntado por b, en vez de stdin.
sscanf(buffer, “%,s%s”,uno,dos,tres);
setbuf
#include
Funciones relacionadas: cscanf, fscanf, scanf, vscanf.
void setbuf(FILE *f, char *buffer);
Asigna un buffer a un flujo.
tmpfile
FILE *tmpfile(void);
#include
setbuf(fx, buffer);
Funciones relacionadas: setvbuf.
setvbuf
#include
Crea un archivo temporal y devuelve un puntero a ese flujo.
if((aux = tmpfile()) == NULL)...
Funciones relacionadas: tmpnam.
int setvbuf(FILE *f, char *b, int t, size_t l);
tmpnam
#include
Asigna el buffer b de tamaño l y el tipo t con el flujo (archivo) f. Los
valores correctos de t son: _IOBF, _IONBF e _IOLBF.
setvbuf(demo, buffer, _IOFBF, 120);
Funciones relacionadas: setbuf.
sprintf
int sprintf(char *b, const char *f[,arg,...]);
#include
Escribe datos con formato en una cadena. Se diferencia de printf en
que la salida generada se sitúa en el array apuntado por b.
sprintf(cad, “&s %d %c”, “uno”,5,´7´);
Funciones relacionadas:
vsprintf.
sprintf, printf, vprintf, vfprintf,
char *tmpnam(char *s);
Genera un único nombre de archivo y lo guarda en el array apuntado por s.
tmpnam(prueba);
Funciones relacionadas: tmpfile.
ungetc
int ungetc(int c, FILE *f);
#include
Sitúa un carácter, excepto la constante EOF, en el buffer asociado con un
archivo abierto para entrada con buffer.
ungetc(car, stdin);
Funciones relacionadas: getc.
sscanf
#include
ungetch
#include
int sscanf(const char *b, const char *f[,dirección,...]);
int ungetch(int ch);

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 645
Empuja un carácter en la memoria intermedia del teclado.
char ch;
ch = getch();
ungetch(ch);
vfprintf,
vprintf,
vsprintf
#include
#include
int vfprintf(FILE *f, const char *f, lista_va lista_arg);
int vprintf(const char *f, lista_va lista_arg);
int vsprintf(char *b, const char *f, lista_va lista_arg);
Escribe salida con formato utilizando un puntero a una lista de argumentos.
vprintf(formato, nota);
Funciones relacionadas: fprintf, printf, sprintf, va_arg,
va_end, va_strat.
vsscanf
#include
#include
int vsscanf(const char *b, const char *f, lista_va
lista_arg);
Funciona igual que sscanf, excepto que en vsscanf es utilizado un
puntero a una lista de variables en lugar de a las propias variables.
vsscanf(buf_en, formato_p, arg_p);
Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.
Funciones de bajo nivel
Las declaraciones de las funciones de bajo nivel se incluyen en los archivos
de cabecera io.h, fcntl.h, sys|types.h y sys|sta.h. A diferencia de
las funciones stream, las funciones de bajo nivel no requieren el archivo de
inclusión stdio.h.
vfscanf
#include
#include
int vfscanf(FILE *F, const char *f, lista_va lista_arg);
Lee entrada con formato de un flujo, tal como scanf, excepto que vfscanf
acepta un puntero a la lista de argumentos.
vfscanf(demo, formato, arg);
Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf.
_close, close
int _close(int h);
int close(int h);
#include
Cierra el archivo especificado en h. Estas funciones se utilizan con
_open y open.
close(f1);
Funciones relacionadas: fclose, fopen, open.
vscanf
#include
int vscanf(const char *f, lista_va lista_arg);
Lee una entrada con formato de un flujo; similar a scanf, excepto que
vscanf acepta un puntero a la lista de argumentos.
vscanf(formato, argumento);
Funciones relacionadas: fscanf, scanf, sscanf, fsca.
_creat
creat
int creat(const char *cam, int modo);
int _creat(const char *cam, int atributo);
#include
#include
#include
Crea un nuevo archivo o abre y trunca un archivo existente. _creat()
actúa igual que creat(), excepto que utiliza un byte de atributo del DOS.

646 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
Modo
S_IWRITE
S_IREAD
S_IREAD|S_IWRITE
Significado
fh= creat(“datos”,S_IREAD|S_IWRITE);
Permiso de escritura.
Permiso de lectura.
Permiso de lectura y escritura.
Funciones relacionadas: chmod, close, open umask.
creatnew
int creatnew(const char *camino, int atributo);
Crea un archivo nuevo con los atributos especificados.
h = creatnew(“F.FIL”,0);
Funciones relacionadas: _creat, fopen, open.
#include
#include
eof
int eof(int d);
#include
Comprueba si el archivo especificado en el descriptor d es el final de
archivo (se devuelve 1 si se alcanza el final del archivo. 0 si no se alcanza
el final del archivo, –1 indica un error y errno toma valor EBADF: número
de archivo incorrecto).
while(!eof(fx))
Funciones relacionadas: feof, ferror, perror.
lseek
#include
#include
long lseek(int d, long desp, int origen);
La función lseek mueve el puntero asociado con el descriptor d a una
nueva posición que está emplazada desp bytes de origen.
pos = lseek(fh, OL, SEEK_CUR);
creattemp
#include
#include
Funciones relacionadas: fseek, tell.
int creattemp(char *camino, int atributo);
Crea un único archivo temporal con byte de atributo en el directorio
escrito por camino.
if((h = creattemp(“nombre”,9))== -1
Funciones relacionadas: tmpfile.
open
#include
#include
#include
int open(const char *f, int a[, unisgned m]);
Abre el archivo especificado en f para lectura o escritura. El argumento
a indica el tipo de operación permitida y m el tipo de permiso.
dup, dup2
#include
Indicador
Lectura/escritura
Significado
int dup(int h);
int dup2(int h1, int h2);
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace
de archivo (dup2).
viejostdout = dup(STDOUT);
dup2(fptr, STDOUT);
Funciones relacionadas: close, creat, open.
O_RDONLY
Abrir para lectura.
O_WRONLY
Abrir para escritura.
O_RDWR
Abrir para lectura y escritura.
O_NDELAY
Pone el puntero del archivo al final del archivo.
O_APPEND
Se crea el archivo y se fijan atributos del archivo.
O_TRUNC Trunca el archivo a 0.
O_EXCL
Se utiliza con O_CREAT.
O_BINARY
Abrir archivo en modo binario.
O_TEXT
Abrir archivo en modo texto.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 647
open(“OPEN.OUT”, 0_WRONLY|O_CREAT, S_IREAD|IWRITE);
if((h = open(“open.tst”, O_CREAT))==1)...
Funciones relacionadas: access, chmod, close, creat, fopen.
sopen
int sopen(char *f, int a, int s[, int m]);
#include
#include
#include
#include
Abre un archivo f con acceso a en modo compartido en un entorno de
red y con el tipo s de compartición permitido en el archivo y modo m.
Devuelve la posición actual del puntero del archivo especificado por d.
posi = tell(desf);
Funciones relacionadas: ftell, lseek.
write
int write(int d, void *buffer, unsigned lon);
#include
Escribe datos en un archivo (lon bytes en el archivo asociado con d
desde el buffer apuntado por buffer).
write(fx, grande, 60000);
Indicador
Lectura/escritura
O_RDONLY
O_WRONLY
O_RDWR
S_IWRITE
S_IREAD
S_IWRITE|S_IREAD
Significado
Abrir para lectura.
Abrir para escritura.
Abrir para lectura y escritura.
Acceso de escritura.
Acceso de lectura.
Acceso de lectura y escritura.
Funciones relacionadas: creat, open, read, sopen.
Funciones de consola y puertos de E/S
Las funciones de E/S sirven para interactuar con el teclado y la pantalla.
Estas funciones se declaran en el archivo de cabecera conio.h.
df = sopen(“C:||autoexec.bat”, O_RDONLY, SH_DENYRW, S_IREAD);
Funciones relacionadas: close, fopen.
read
int read (int d, void * buffer, unsigned lon);
#include
Lee lon bytes del archivo asociado con d en el buffer apuntado por
buffer.
cgets
char *cgets(char *cadena);
#include
Lee una cadena de caracteres directamente de la consola, y almacena la
cadena y su longitud en la posición apuntada por cadena.
entrada = cgets(cadena);
Funciones relacionadas: cputs, getch, getche.
read(fx, buffer, 100);
cprintf
#include
tell
long tell(int d);
#include
int cprintf(const char *formato[,arg,...]);
Escribe salida con formato directamente en la consola. Observe que
cprintf no traduce el carácter (\n) a una combinación (CR-LF), en su lugar,

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
un retorno de carro (CR).
cprintf(“Cubo de %2d es %rd\r\n”,i, i * i * i);
Funciones relacionadas: printf.
getpass
char *getpass(const char *indicador);
#include
Lee una palabra de paso por consola, que no se visualiza en pantalla
(menos de ocho caracteres de longitud).
cputs
int cputs(const char *cad);
#include
palabrapaso = getpass(“Introduzca clave”);
Funciones relacionadas: getch
Escribe una cadena en la pantalla. No se envía ningún carácter de nueva
línea después de la cadena.
cuts(“Está usted seguro(s/n)?”);
inport, inportb
int inport(int puerto);
unsigned char inportb(int puerto);
#include
Funciones relacionadas cprintf.
cscanf
int cscanf(char *formato [,dirección,...]);
#include
Lee caracteres con formato directamente desde la consola en la posición
dada por dirección.
Lee una palabra de 16 bits (inport) o un byte (inportb) de un puerto
de E/S especificado por puerto.
La función inport es útil para leer dos puertos adyacentes a la vez, e
inportb para controlar dispositivos de entrada/salida.
palabra = inport(PORT_8259_20);
P21 = inportb(PORT_8259_21);
Funciones relacionadas: outport, poutportb.
cscanf(“%d%d%d, &dia, &mes, &hora);
Funciones relacionadas: fscanf, scanf, sscanf.
kbhit
int kbhit(void);
#include
Comprueba si se ha pulsado recientemente una tecla.
get, getche
int getch(void);
int getche(void);
#include
Lee un carácter de la consola sin eco (getch) o con eco (getche).
printf(«Pulse cualquier tecla para salir»);
getch();
Funciones relacionadas: cgets, getchar, ungetch.
// visualizar hasta que pulsa una tecla
while(!kbhit())
cputs(“Pulse una tecla”);
Funciones relacionadas: getch, getche.
outport, outportb
void outport(int puerto, int palabra);
void outportb(int puerto, unsigned char byte);
#include

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
puerto de E/S.
outport(23,0);
outport(´A´, 0)
// 23 fuera del puerto
// A fuera de puerto
Funciones relacionadas: inp, inport, inportb, inpw.
putch
int putch(int c);
Escribe un carácter en la consola (sin acción del buffer).
putch(car); putch(´\n´); putch(´x´);
Funciones relacionadas: getch, getche.
ungetch
int ungetch(int c);
#include
#include
Sitúa un carácter en el buffer del teclado de modo que es el siguiente
carácter leído en la consola.
if(c =!EOF) ungetch(c);
ungetch(car);
Funciones relacionadas: getch, getche, ungetc.
F.11.
FUNCIONES DE GESTIÓN DE ARCHIVOS
Verifica si existe un archivo y, en caso afirmativo, los permisos de acceso
al archivo.
Modo
Significado
00 Se verifica existencia del archivo.
01 Ejecutar.
02 Verifica permiso de escritura.
04 Verifica permiso de lectura.
06 Verifica permiso de lectura y escritura.
return(access(nombre, 4)==-1)
Funciones relacionadas: chmod, fstat, stat.
chmod
int chmod(const char *camino, int pmodo);
Cambia los permisos de lectura/escritura de un archivo.
r = chmod(“prueba.tst”, S_IREAD);
Funciones relacionadas: access, fstat, stat.
pmodo
S_IWRITE
S_IREAD
S_IREAD|S_IWRITE
#include
#include
Permiso de acceso
Escritura.
Lectura.
Lectura/Escritura.
El sistema de archivos es un componente clave del/de la PC. Todas las aplicaciones
y datos residen en archivos. Las funciones de gestión de archivos
permiten establecer y verificar permisos de acceso a archivos. La mayoría
de las funciones están en el archivo de cabecera io.h, y las restantes en
sys|stat.h, dir.h y stdio.h.
chsize
int chsize(int manejador, long longitud);
Cambia el tamaño del archivo.
#include
access
int access(const char *nomarch, int modo);
#include
chsize(fh, 5);
Funciones relacionadas: access, chmod, fstat, stat.

650 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
filelength
long filelenght(int manejador);
Obtiene la longitud de un archivo en bytes.
filelength(fh);
Funciones relacionadas: fileno, filestat, stat.
fnmerge
#include
#include
void fnmerge(char *camino, const char *unidad,
const char *dir, const char *nombref, const char *ext);
Crea un nombre de camino completo (letra, unidad, camino directorio,
nombre de archivo y extensión del archivo). En Microsoft, la función equivalente
es _makepath.
fnmerge(camino,”C:”,\\aux,”resultado”,”.dat”);
// nombre de camino”C:\aux\resultado.dat”
Funciones relacionadas: fnsplit.
fnsplit
int fnsplit(const char *camino, char *unidad,
char *dir, char *fnombre, char *ext);
#include
Devuelve información sobre el archivo especificado en la estructura de
tipo stat apuntada por buffer. La estructura stat es:
struct stat {
short st_dev;
short st_ino;
short st_mode
short st_nlink;
int st_uid;
int st_gid;
int st_rdev;
long st_size;
long st_atime;
long st_mtime;
long st_ctime;
};
fstat(fich, &info);
// unidad o dispositivo
// número inodo (UNIX)
// modo archivo
// número enlaces (DOS,1)
// id de usuario (UNIX)
// id de grupo (sólo UNIX)
// dispositivo UNIX
// tamaño archivo en bytes
// hora último acceso
// hora última (UNIX)
// hora creación
Funciones relacionadas: access, chmod, stat.
isatty
int isatty(int h);
#include
Determina si es un dispositivo orientado a carácter (terminal, consola,
impresora o puerto serie).
if(isatty(fileno(stdout)))
puts(“es consola”);
Separa un nombre de camino completo en sus componentes: letra, unidad,
camino, nombre y extensión del archivo.
f = fnsplit(c, unidad, dir, arch, ext);
lock
int lock(int h, long d, long n);
#include
Funciones relacionadas: fnmerge.
Bloquea un número de bytes n del archivo h (manejador) con desplazamiento
se utiliza para compartición de archivos (orden SHARE de MS-
DOS). En Visual C++, la función equivalente es locking.
fstat
#include
res lock(h, 0L,256);
bloque de 256 bytes
int fstat(int h, struct stat *buffer);
Funciones relacionadas: sopen, unlock.

mktemp
char * mktemp(char *plantilla);
#include
BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 651
modo 0_BINARY(binario) 0_TEXT(texto)
setmode(fileno(stdin), 0_BINARY);
// modo binario
Crea un único nombre de archivo modificando una plantilla dada como
argumento, plantilla toma la forma basexxxxxx, donde bas es el nombre
que se proporciona y x los caracteres a modificar.
char modelo = “tcbxxxxxx”;
mktemp(modelo);
Funciones relacionadas: tmpfile, tmpnam.
Funciones relacionadas: fopen, open.
stat
#include
int stat(char *f, struct stat *buffer);
Obtiene información sobre el estado de un archivo existente f.
resultado = stat(“stat.c”,&buf);
remove
#include
Funciones relacionadas: access, chmod, fstat.
int remove(const char *camino);
Borra el archivo especificado en camino.
remove(“C:\\ux\\demo”); // borra demo
Funciones relacionadas: unlink.
rename
#include
int rename(const char *vn, const char *nn);
Renombre el archivo vn a nn.
umask
unsigned umask(unsigned Pmodo);
#include
Establece la máscara de permisos de lectura/escritura usados por open
y create.
Pmodo S_IREAD (sólo lectura)
S_IWRITE (sólo escritura)
S_IREAD|S_IWRITE (lectura/escritura)
viejamascara = umask(S_IWRITE);
Funciones relacionadas: chmod, creat, mkdir, open, sopen.
int resultado;
resultado = rename(viejo, nuevo);
Funciones relacionadas: creat, fopen, open.
unlink
int unlink(const char *camino);
#include
#include
#include
setmode
int setmode(int h, int modo);
#include
#include
Borra un archivo especificado en camino, que no sea de sólo lectura.
result = unlink (“demo.jnk”);
if (result==0)
printf (“unlink tuvo éxito”);
Permite cambiar el modo del archivo abierto entre texto y binario.
Funciones relacionadas: remove.

652 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
unlock
#include
int unlock(int h, long o, long l);
Desbloquea una sección del archivo h que ha sido bloqueada con lock.
unlock(m,OL,256); // desbloquea 256 bytes
Funciones relacionadas: lock, sopen.
Las funciones complejas son propias de Borland C++ y no son exportables.
Clase bcd
La clase bcd permite manipular números almacenados en notación decimal
codificado a binario (BCD) y proporciona hasta 17 dígitos decimales de
precisión, y un rango de 1 × 10 -125 a 1 × 10 125 .
F.12.
FUNCIONES MATEMÁTICAS
El C original de K&R fue diseñado, inicialmente, como un lenguaje de programación
de sistemas, su uso ha sido muy escaso en el campo del cálculo
científico. Sin embargo, desde la normalización de ANSI C y su extensa
biblioteca matemática, C se ha convertido en un fuerte rival del lenguaje
científico por excelencia, FORTRAN. C soporta operaciones de coma flotante
e incluye también un rico conjunto de funciones matemáticas. Borland
C++ ha ampliado las propiedades de ANSI C estándar.
Los archivos de cabecera que contienen funciones matemáticas son:
bcd.h, complex.h, float.h, math.h, stdlib.h. Las funciones de Borland
C++ no incluidas en ANSI C son: cabs, _clear87, _control87,
_fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min,
poly, pow10, random, randomize, _rotl, _rotr, _status87.
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.
Clase complex
Borland C++ incluye una estructura complex en el archivo de cabecera
math.h, cuyos miembros son la parte real e imaginaria de un número complejo
z y que se define así:
struct complex
{
double x;
double y;
}
// parte real del número complejo
// parte imaginaria del complejo
abs versión real
versión compleja
int abs (int x);
double abs(complex x);
#include
#include
#include
Proporciona el valor absoluto de un entero o de un número complejo:
abs(-50) devuelve 50. Para utilizar números complejos se requiere el
archivo de cabecera complex.h.
x = abs(-7) // x es 7
Funciones relacionadas: cabs, fabs, labs.
acos
double acos(double x);
complex acos(complex x);
#include
#include
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.
angulo = acos(0.5); // el ángulo devuelto es /3
Funciones relacionadas: cos, matherr.
Se puede declarar e inicializar un número complejo (x + yi) de esta
forma:
arg
#include
struct complex z = {1.5,1.5}
// z = 1.5 + i1.5;
double arg(complex x);

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
plano complejo.
complex z;
double angulo;
z = complex(1.5, 4.5);
angulo = arg(z);
Calcula el arco tangente de y/x. El resultado es un ángulo de valor
comprendido entre – y radianes.
angulo = atan2(y, x);
Funciones relacionadas: atan, matherr, tan.
Funciones relacionadas: complex, norm, polar.
cabs
#include
asin versión real
versión compleja
double asin(double x);
#include
#include
Calcula el arco seno del argumento x; el valor de x debe estar comprendido
entre –1 y 1. La función asin() devuelve un valor entre –/2 y ,
el valor de x debe ser en radianes.
Z = asin(0.7543);
Funciones relacionadas: matherr, sin.
double babs(struct complex z);
Calcula el valor absoluto de un número complejo almacenado en una
estructura de tipo complex.
struct complex z;
double complejo;
z.y = 3.5
z.y = 2.4
complejo = cabs(z);
printf(“valor absoluto %lf\n”, complejo);
Funciones relacionadas: fabs, hypot, matherr, sqrt.
atan versión real
versión compleja
double atan(double x);
#include
#include
ceil
#include
double ceil (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()
devuelve un valor en el rango de –/2 a /2.
#include
complex atan(complex x);
angulo = atan(1.0);
Funciones relacionadas: atan2.
// ángulo es “Pi/4” (45 grados)
redondeo = ceil(5.1) // redondeo es 6
Funciones relacionadas: floor.
_clear87
#include
unsigned int _clear87(void);
Borra (limpia) la palabra del estado de coma flotante.
atan2
double atan2 (double y, double x);
#include
estado = _clear87();
Funciones relacionadas: _control87, _status87.

654 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
_control87
#include
unsigned int _control87(unsigned int nuevo, unsigned int
mascara);
Obtiene y establece la palabra de control de coma flotante. Cuando se
utiliza un coprocesador matemático 8087, _control87 establece su palabra
de control.
estado = control87(PC24,MCW_IC);
// precisión 24 bits
Funciones relacionadas: _clear87, _status87.
La función div() calcula el cociente entero y el resto de x por y. La
función devuelve una estructura div_t definida en stdlib.h como
typedef struct
{
int quot;
int rem;
} div_t;
// cociente
// resto
div_t resultado;
resultado = div(35, 8);
// resultado.cociente = 4, resultado.resto = 3
cos
#include
exp
#include
#include
double cos(double x);
complex cos(complex x);
double exp(double x);
complex exp(complex x);
Calcula el coseno del argumento x. El argumento x se especifica en
radianes y devuelve un valor en el rango de –1 a 1.
coseno_x = cos(1.6543);
Funciones relacionadas: acos, sin.
Calcula el exponencial de x:e x ; donde e es la base del logaritmo natural
(e = 2.7182818).
x = 100.00;
y = exp(x);
printf(“El exponencial de x = %f.\n”,y);
cosh
#include
Funciones relacionadas: log, pow.
double cosh(double x);
complex cosh(complex x);
Calcula el coseno hiperbólico de la variable x. Si el argumento pasado
a cosh() es demasiado grande, se produce un error de rango.
fabs, fabsl
double fabs(double x);
long double fabs(long double x);
#include
x = 1.00
printf(“x = %f.\n\n”,x);
y = cosh(x);
printf(“coseno hiperbólico x = %f.\n\n”, y);
Funciones relacionadas: sinh.
Calcula el valor absoluto de un número en coma flotante x.
y = fabs(-7.25); // y vale 7.25
Funciones relacionadas: cabs.
div
#include
floor
#include
div_t div(int x, int y);
double floor(double x);

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 655
Redondea por defecto el valor de x.
x = floor(6.25); // x vale 6
Funciones relacionadas: ceil.
double x, y;
int n;
x = 17.5;
y = frexp(x, &n);
printf(“frexp(%f, &n) = %f, n = %d\n”,x,y,n);
Funciones relacionadas: exp, ldexp, modf.
fmod
#include
hypot
#include
double fmod(double x, double y);
Calcula el resto de la división real x por y.
resto = (fmod(5.0, 2.0); // resto igual a 1.0
Funciones relacionadas: floor.
_fpreset
void _fpreset(void);
#include
Reinicializa el paquete matemático de coma flotante. Debe utilizarse
después de las llamadas a las funciones system(), exec(), span() sobre
máquinas con coprocesadores matemáticos.
_fpreset(); // inicializa paquete de coma flotante *t
Funciones relacionadas: _control87, signal.
double hypot(double x, double y);
Calcula la hipotenusa de un triángulo rectángulo cuyos lados son x e y.
Una llamada a hypot equivale a lo siguiente:
sqrt(x * x, y * y);
double x = 3.0; y = 4.0;
printf(“%lf”, hypot(x, y));
imag
double imag(complex x);
#include
Devuelve la parte imaginaria de un número complejo x. Esta función no
es transportable.
double x = 3.4, y = 4.5;
complex = complex(x, y);
cout

656 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
ldesp, ldespl
double ldesp(double x, int exp);
long double ldexpl(long double x, int exp);
Calcula y devuelve el valor real de x*e exp .
double x = 4.0,y;
int p = 5;
y = ldexp(x, p);
#include
stderr, la variable global errno toma el valor EDOM y devuelve el valor
HUGE_VAL. Si x es 0, la función imprime un mensaje de error SING en
stderr, devuelve el valor HUGE_VAL y fija errno a ERANGE.
hdouble x, y;
x = 10;
y = log(x);
y = log10(x);
Funciones relacionadas: exp, matherr pow.
Funciones relacionadas: frexp, modf.
_lrotl
#include
ldiv
ldiv_t ldiv(long int x, long int y);
#inxlude
Calcula el cociente y el resto de la división x/y. La función ldiv
devuelve una estructura de tipo ldiv_t que comprende el cociente y el
resto.
typedef struct
{
long quot;
long rem;
} ldiv_t;
long x = 5258625, y = 341654;
ldiv_t resultado;
resultado = ldiv(x, y);
printf(“el cociente y el resto es %ld, %ld,\n”, resultado.quot,
resultado.rem);
Funciones relacionadas: div.
unsigned long _lrotl(unsigned long x, int c);
Se utiliza _lrotl para rotar a la izquierda los bits de una variable entera
larga sin signo x. La rotación de un bit a la izquierda, una posición, significa
que el bit más a la izquierda sale fuera y se inserta en su posición el
siguiente bit de mayor peso, y los restantes bits se desplazan una posición a
la izquierda.
unsigned long x = 0x0fac45491;
printf(“x desplazado 4 veces es”, _lrotl (x, 4);
Funciones relacionadas: _lrotr, _rotl, _rotv.
_lrotr
unsigned long _lrotr(unsigned long x, int c);
#include
Rota a la derecha los bits de x. Rotación a derecha de un bit significa
salir fuera el bit de menor peso y los restantes se desplazan una posición a
la derecha.
val_r = _lrotr(x, 4);
log, log10
#include
#include
Funciones relacionadas: _lrotl, _rotl, _rotr.
double log(double x);
double log10(double x);
Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x.
Si x es negativo, ambas funciones devuelven un error de dominio DOMAIN en
matherr
_matherrl
int matherr(struct exception *e);
int _matherrl(struct _exception1 *e)
#include

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
llaman a la rutina adecuada matherr cuando se detecta un error. Se puede
desarrollar su propia versión de matherr para personalizar su tratamiento
de errores. Para profundizar en esta función, consultar su referencia en
Library Reference de Borland C++ (págs. 352-353).
Funciones relacionadas: Las funciones matemáticas.
max
#include
(tipo) max(a, b);
Devuelve el mayor de dos valores. Ambos argumentos y la declaración
de la función deben ser del mismo tipo.
double dbl1, dbl2, dblmax;
dblmax = max(dbl1, dbl2);
Funciones relacionadas: min.
min
#include
(tipo) min(a, b);
Devuelve el menor de dos valores. Ambos argumentos y la declaración
de la función deben ser del mismo tipo.
int i1, i2, minent;
minent = min(i1, i2);
polar
complex polar(double modulo, double angulo);
#include
Devuelve un número complejo con una magnitud (módulo) y ángulo
dado.
complex < = complex(x, y);
polar(mag, ang)es lo mismo que complex(mag*cos(ang), mag
*sin(ang);
Funciones relacionadas: Sólo existe en C+.
poly
double poly(double x, int n, double c[]);
#include
Se utiliza poly para evaluar un polinomio en x, de grado n y cuyos coeficientes
son los correspondientes al array c. La expresión utilizada para
evaluar el polinomio es:
c[n]x n +c[n-1] n-1 +...+c[2](x 2 +c[1](x+c[0]
// polinomio: 3x**2 + 2x + 1//
double c[] = {-10.0,2,c);
Funciones relacionadas: pow.
Funciones relacionadas: max.
rand
#include
modf, modfl
#include
int rand(void);
double modf(double x, double *partent);
long double modfl(long double x, long double *partent);
La función modf divide un número de coma flotante en dos partes, entera
y decimal. La parte entera de x se almacena en la posición a cuya dirección
apunta partent, y la parte decimal es devuelta por la función.
pardecimal = modf(36.95, &parte_entera(;
// parte entera 36, parte decimal .95
Funciones relacionadas: frexp,ldexp.
Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; esta
constante simbólica está definida en y su valor es 2 15 -1. Para inicializar
el generador de números pseudoaleatorios se debe utilizar randomize.
Para obtener un número en el rango de 0 a (n-1) hay que utilizar random.
// visualizar 10 números aleatorios //
for(i = 0; 1 < 10; i++)
printf(“%6d\”, rand());
Funciones relacionadas: random, randomize, srand.

658 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
random
#include
Rota el valor de x,c bits a la izquierda.
int random(int x);
Genera un número pseudoaleatorio en el rango de 0 a x-1.
// obtener un número aleatorio entre 0 y 20
numa1 = random(21);
Funciones relacionadas: rand, randomize.
modelo_nuevo = _rotl(0x1234,8);
// resultado es 3412h
Funciones relacionadas: _lrotl, _rotr, _rotr.
_rotr
unsigned _rotr(unsigned x, int c);
#include
randomize
#include
#include
Se utiliza _rotr para rotar a la derecha el valor de x,c bits.
_rotr(val, 4);
void randomize(void);
Inicializa (genera una semilla) el generador de números pseudoaleatorios
con una semilla aleatoria que es función de la hora actual. Esta función
impide que se repitan las mismas secuencias de números aleatorios en diferentes
ejecuciones.
randomize();
Funciones relacionadas: rand, random, srand.
real
double real(complex x);
double real(bcd x);
#include
#include
Devuelve la parte real de un número complejo x o convierte un número
BCD a float, double o long double.
complex z = complex(x, y)
cout

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 659
sqrt
double sqrt(double x);
complex sqrt(complex x);
Calcula la raíz cuadrada de un número x no negativo.
printf(“%lf”,sqrt(25.0); // se visualiza 5
Funciones relacionadas: exp, log, pow.
srand
void srand(unsigned x);
#include
#include
srand inicializa el generador de números aleatorios con la semilla x. Si
x es 1, el generador se reinicializa; cualquier otro valor de x fija el generador
a un punto inicial aleatorio.
srand(semilla);
Funciones relacionadas: rand, randomize.
_status87
#include
tanh
double tanh(double x);
complex tanh(complex x);
Calcula la tangente hiperbólica de x.
a = tanh(x);
Funciones relacionadas: cosh, tanh.
F.13.
#include
#include
FUNCIONES DE MANIPULACIÓN DE BLOQUES
DE MEMORIA (BUFFERS)
Las rutinas de manipulación de buffers son una forma general de las rutinas
de manipulación de cadenas que operan sobre éstas en C. Son útiles para trabajar
con áreas de memoria sobre la base de carácter a carácter. Un buffer es
un array de caracteres similar a una cadena de caracteres. Sin embargo, al
contrario que las cadenas, los buffers no terminan normalmente con un
carácter nulo (´\0´). Por consiguiente, las rutinas de manipulación de buffers
siempre toman un argumento longitud o cuenta.
Las rutinas de manipulación requieren que el archivo de cabecera
se incluya en su programa.
unsigned int _status87(void);
Obtiene el contenido de la palabra de estado de coma flotante.
estado = _status87();
Funciones relacionadas: _clear87, _control87.
tan
double tan(double x);
complex tan(complex x);
#include
#include
memccpy
#include
#include
void *memccpy(void *dest, const void *s, int c, size_t n);
Copia n bytes desde s a dest hasta que n bytes han sido copiados o c
se copia a dest.
res = memccpy(buf_dest, bufen, ´c´, 81);
Funciones relacionadas: memcpy, memmove, movedata, movmem.
Calcula la tangente de x (x, se supone en radianes).
y = tan(x)
memchr
#include
#include
Funciones relacionadas: atan.
void *memchr(const void *buf, int c, size_t n);

660 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
Busca un carácter específico c en un buffer (buf) examinando los n primeros
caracteres.
result = memchr(direc, ´I´, 40);
Funciones relacionadas: memcmp, memicmp.
memmove
#include
#include
void *memmove(void *dest, const void *f, size_t n);
Mueve n bytes de un buffer (f) a otro (dest).
memcmp
#include
Funciones relacionadas: memccpy, memcpy, movedata.
int memcmp(const void *b1, const void *b2, size_t n);
Compara n bytes de un buffer (b1) con los de otro buffer (b2). Devuelve
un valor:
< 0 si b1 < b2
= 0 si b1 = b2
> 0 si b1 > b2
resultado = memcmp(buf1, buf2, sizeof(buf1));
Funciones relacionadas: memicmp.
memcpy
#include
void *memcpy(void *dest, const void *fuente, size_t n);
Copia n bytes de fuente en dest. Devuelve un puntero a dest.
memcpy(dest, fuente, 80):
Funciones relacionadas: memccpy, memmove, movedata.
memset
void *memset(void *s, int c, size_t n);
Fija los n primeros bytes del array s al carácter c.
resultado = memset(buffer,´1´, 50);
#include
Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.
movedata
#include
#include
void movedata (unsigned ss, unsigned so,
unsigned ds, unsigned do, size_t n);
Mueve n bytes desde ss a ds, donde ss es el segmento fuente, so es el
desplazamiento fuente, ds es el segmento destino, do es el desplazamiento
destino y n es el número de bytes que hay que mover.
movedata(seg1, off, seg2, dest_off, 4096);
memicmp
#include
#include
Funciones relacionadas: memcpy, memmove, movmem, segread.
int memicmp (const void *b1, const void *b2, size_t n);
movmem
#include
Compara un número de bytes de un buffer (b1) con otro (b2) sin hacer
caso del tamaño de las letras en los dos buffers.
if(memicmp(buf1, buf2, 15) == 0)
puts(“Los buffers son iguales en los 15 primeros bytes \n”);
Funciones relacionadas: memcmp.
void movmem(void *fuente, void *destino, unsigned n);
Copia n bytes de fuente a destino.
movmem(&fuente[6], fuente, sizeof(fuente));
Funciones relacionadas: memmove.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 661
setmem
#include
clrscr
#include
void setmem(void *dest, unsigned long, char c);
Fija un bloque de long bytes en el buffer dest al carácter c. setmem es
útil para inicializar buffers.
setmem(buffer, 60, ´t´);
Funciones relacionadas: memset.
void (clrscr(void);
Borra la ventana actual y pone el cursor en la esquina superior izquierda
(1,1).
clrscr();
Funciones relacionadas: clreol, textbackground, window.
swab
#include
delline
#include
void swab(char *fuente, char *destino, int n);
Copia un número par de bytes de una posición a otra, intercambiando al
mismo tiempo cada par de bytes adyacentes.
swab(“mnpq”, resultado, 4);
// resultado es “nmpq”
Funciones relacionadas: Sólo está disponible en sistemas UNIX.
F.14.
FUNCIONES DE PRESENTACIÓN DE TEXTO
Las funciones de presentación de texto permiten definir coordenadas de una
ventana de texto en la pantalla y manipular texto. Con estas funciones se
puede posicionar texto en cualquier parte de la pantalla, seleccionar atributos
de texto (tales como subrayado, vídeo inverso, parpadeo, colores de
fondo y primer plano), así como actuar sobre ventanas de texto. Estas funciones
se encuentran esencialmente en el archivo de cabecera conio.h.
void delline(void);
Borra la línea completa que contiene el cursor y desplaza hacia arriba
las líneas que haya debajo.
delline();
Funciones relacionadas: clreol, clrscr.
gettext
#include
int gettext(int izda, int arriba, int derecha, int abajo,
void *textbuf);
Copia el contenido de un área rectangular de la pantalla al buffer cuya
dirección se da en el argumento textbuf. Todas las coordenadas son absolutas.
if(!gettext(1,1,30,20, pan_grabada))
puts(“color”);
clreol
#include
Funciones relacionadas: movetext, puttext.
void clreol(void);
Borra la línea actual desde la posición del cursor al final de la línea.
clreol()
Funciones relacionadas: clrscr, delline, textbackground, window.
gettextinfo
void gettextinfo(struct text_info *r);
#include
Devuelve información relativa a las coordenadas de la ventana actual,
posición del cursor dentro de la ventana, atributo del texto, las dimensiones

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
estructura text_info.
struct text_info {
unsigned char winleft; // coordenadas x, y esquina superior
// izquierda
unsigned char wintop; // ventana actual
unsigned char winright; // coordenadas x, y esquina inferior
// derecha
unsigned char winbottom; // ventana actual
unsigned char attribute; // atributo texto actual
unsigned char normattr; // atributo texto normal
unsigned char currmode; // modo texto actual
unsigned char screenheight;// altura de la pantalla
unsigned char screenwidth; // anchura pantalla
unsigned char curx; // coordenada x cursor
unsigned char cury; // coordenada y cursor
};
gotoxy
void gotoxy(int x, int y);
#include
Mueve el cursor a una posición especificada (columna x, fila y) dentro
de la ventana de texto actual.
gotoxy(15, 4);
Funciones relacionadas: wherex, wherey, window.
Inserta una línea en blanco en la ventana de texto actual en la posición
del cursor, desplazando el resto de las líneas situadas debajo.
insline();
Funciones relacionadas: clreol, delline, window.
lowvideo
void lowvideo(void);
Activa los caracteres a baja intensidad.
lowvideo();
#include
Funciones relacionadas: highvideo, normvideo, textcolor.
movetext
#include
iont movetext(int izda, int arriba, int dcha,
int abajo, int nuevoizda, int nuevoarriba);
Copia el contenido de una zona rectangular de la pantalla (en modo
texto) a otro rectángulo en la pantalla de las mismas dimensiones.
if (!movetext(1, 1, 30, 20, 40, 40))
puts(“victoria”);
highvideo
#include
Funciones relacionadas: gettext, puttext.
void highvideo(void);
Activa caracteres de alta intensidad.
highvideo();
Funciones relacionadas: lowvideo, normvideo, textcolor.
normvideo
void normvideo(void);
#include
Reinicializa los atributos de texto al valor que tenían antes de que arranque
el programa.
insline
void insline(void);
#include
normvideo();
Funciones relacionadas: highvideo, lowvideo, textattr, textcolor.

BIBLIOTECA DE FUNCIONES ESTÁNDAR ANSI/ISO C++ Y BORLAND C++ 5.0 663
puttext
#include
textbackground
#include
int puttext(int izda, int arriba, int dcha, int abajo,
void *textbuf);
Copia el contenido de un buffer en una zona rectangular de la pantalla
en modo texto.
void textbackground(int colorfondo);
Establece el color de fondo para texto vidualizado.
textbackground(2);
puttext(3, 1, 32, 22, buffertexto);
Funciones relacionadas: gettext, movetext.
textcolor
#include
void textcolor(int colorprimerplano);
_setcursortype
void setcursortype(int estilo_cursor);
#include
Establece el color del primer plano del texto visualizado por cprintf y
cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15
WHITE (blanco).
Cambia la forma del cursor en modo texto. El argumento tiene que ser
una de las constantes.
textcolor(15);t
_NOCURSOR
_SOLIDCURSOR
_NORMALCURSOR
Desactiva el cursor.
Un carácter bloque sólido es el cursor.
Un subrayado parpadeante es el cursor.
Funciones relacionadas: textattr, textbackground.
setcursortype(_SOLIDCURSOR);
Funciones relacionadas: cprintf, cputs.
texmode
void textmode(int nuevomodo);
#include
Conmuta al modo texto especificado por el argumento nuevomodo.
textattr
void textattr(int atrib);
#include
Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia
del texto en la pantalla.
textattr(YELLOW + (RED

664 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
wherex
wherey
int wherex(void);
int wherey(void);
#include
Determina la coordenada x (wherex) y la coordenada y (wherey) de la
posición del cursor en la ventana actual.
xpos = where(x); ypos = where(y);
window
#include
void window(int izda, int arriba, int dcha, int abajo);
Define una región rectangular de la pantalla como la ventana de texto
actual esquina superior izquierda (izda, arriba) y esquina inferior derecha
(dcha, abajo).
window(15, 5, 54, 14);
// ventana de 40 x 10 con origen en (15, 5)
Funciones relacionadas: gettextinfo, textmode.