Biblioteca de Funciones Estándar Ansi/Iso C++ Y Borland C++ 5.0

APNDICE F
BIBLIOTECA DE FUNCIONES ESTNDAR

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 asignacin de memoria.
Funciones de bsqueda y ordenacin.
Funciones de cadena.
Funciones de clasificacin de caracteres.
Funciones de calendario (fecha y hora).
Funciones de control de directorios.
F.8.
F.9.
F.10.
F.11.
F.12.
F.13.
F.14.
Funciones de control de procesos.

Funciones de conversin de datos.
Funciones de entrada/salida.
Funciones de gestin de archivos.
Funciones matemticas.
Funciones de manipulacin de bloques de memoria (buffers).
Funciones de presentacin de texto.
F.2.
FUNCIONES DE ASIGNACIN DE MEMORIA
Esta parte es una revisin breve de la biblioteca de rutinas (funciones) y

archivos include, en tiempo de ejecucin. La biblioteca de Borland C++ es
un conjunto de ms de 450 funciones y macros preparadas para utilizar y
diseadas para su uso en programas C++. La biblioteca en tiempo de ejecucin hace la programacin ms fcil, ya que incluye una amplia variedad de
tareas tales como E/S de bajo y alto nivel, manipulacin de cadenas y archivos, asignacin de memoria, control de procesos, clculos matemticos, etc.
Las rutinas de Borland C++ estn contenidas en los archivos de biblioteca Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ implementa la versin estndar ltima de ANSI C, que entre otras cosas recomienda el uso de los prototipos de funcin en las rutinas de sus programas C++.
Este apndice describe alfabeticamente funciones de la biblioteca Borland C++ y contiene todas las funciones incluidas en ANSI/ISO C++.
Borland C++ almacena informacin en la memoria principal de la computadora por dos mtodos. El primero utiliza variables globales y locales
(incluyendo arrays, cadenas y estructura); en este caso, el almacenamiento
o longitudes fija. Para cambiar el tamao de arrays y cadenas de caracteres
se debe editar el archivo fuente y recompilar su programa. Esta informacin
se almacena en la pila (stack). El segundo mtodo de almacenar informacin es asignar memoria a medida que el programa lo requiera y liberar esta
memoria cuando ya no se necesita; esta accin permite utilizar la misma
F.1.
strrev
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
categoras (en general, se ha procurado respetar la clasificacin dada por
Borland y ANSI, pero con una adaptacin ms prxima al uso diario del
programador /.
Al comienzo de cada categora se hace una breve descripcin de su
cometido principal y se presenta una tabla con las funciones que contiene
cada categora por orden alfabtico, as como una breve sntesis de su descripcin o propsito. A continuacin, por orden alfabtico, se describen las
rutinas de acuerdo al siguiente modelo para cada entrada.
nombre funcin
char *strrev(char *cad)
archivo de cabecera
#include <string.h>
sintaxis
Descripcin
Propsito y breve descripcin de cmo y dnde se utiliza la funcin.
Ejemplo
Una o ms instrucciones o programas sencillos, donde se muestra la explicacin
real de la funcin.
Funciones relacionadas: strcpy, strncpy.
Funciones relacionadas con la funcin descrita.
616
PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
memoria para colas diferentes en un tiempo distinto. Este proceso de asignar memoria se denomina asignacin dinmica de memoria.
Por omisin, cada vez que se ejecuta un programa, DOS establece un
segmento de 64 Kb denominado segmento de cdigo, que contiene su cdigo programa. DOS establece tambin un segmento de 64 Kb denominado
segmento de datos. Su programa puede tener mltiples segmentos de datos
y cdigos.
El segmento de datos se divide en tres regiones: datos del programa
(variables estticas y globales), pila stack (variables locales y argumentos) y montn o montculo heap.
datos de un programa. Si hay xito se devuelve 0; en caso contrario, 1, y la

variable global errnoc toma el valor ENOMEN (insuficiente memoria).
it(brk(nuevo_break) == -1)
perror(brk ha fallado);
Funciones relacionadas: free, farmalloc, malloc, sbrk.

calloc
#include <stdlib.h>
#include <alloc.h>
Segmento de datos
int *calloc(size_t n, size_t s);
Montculo
(heap)
Pila
(stack)
Datos del programa
Despus de asignar partes del segmento de datos a variables estticas y

globales y a la pila, el compilador dedica el resto del segmento de datos al
montculo o heap.
Borland C++ contiene un gran nmero de funciones para asignacin
dinmica de memoria, que realizan una gran variedad de tareas: asignar y
liberar memoria del montculo y de la pila, obtener informacin de bloques
de memoria, etc.
allocmen
#include <dos.h>
int allocmen(unsigned t, unsigned * seg);
La funcin allocmen() establece seg para apuntar a un segmento asignado de memoria de t prrafos (1 prrafo = 16 bytes) de largo. Si hay xito
se devuelve 1, si hay error (falta memoria), allocmen() devuelve el
tamao en prrafos del mayor bloque disponible.
if(allocmen(size, &segadd)!= -1)
printf (Error asignacin memoria \n);
Asigna memoria principal (un bloque de tamao 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 recin 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.

coreleft
#include <alloc.h>
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.
Funciones relacionadas: falloc frremem, malloc, setblock.

farcalloc
brk
#include <alloc.h>
#include <alloc.h>
void far *farcalloc(unsigned long n, unsigned long s);
int brk( void* a)
La funcin brk permite modificar el valor break de un programa. El

valor break es la direccin de la primera posicin ms all del segmento de
Esta funcin asigna n piezas de tamao 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 ESTNDAR ANSI/ISO C++ Y BORLAND C++ 5.0
if(array_grande=farcalloc(20000L, sizeof (int)) NULL)

printf (Fallo en asignacin de memoria\n);
617
Funciones relacionadas: farheapfillfree, farheapwalk, heapfillfree, heapcheckfree, heapwalk.
Funciones relacionadas: calloc, farfree, farmalloc, malloc.

farheapchecknode
farcoreleft
#include <alloc.h>
#include <alloc.h>
int farheapchecknode(void *bloque);
Verifica la consistencia de un solo bloque en el montculo (heap) far.
unsigned long farcoreleft(void);
Determina el nmero total de bytes disponibles en el sistema.
estadoheap = farheapchecknode(arraygrande);
memoria_total_disponible = farcoreleft();
Funciones relacionadas: coreleft, farcalloc, farmalloc.
farheapfillfree
#include <alloc.h>
int farheapfillfree(unsigned int f);

farfree
#include <alloc.h>
Rellena todos los bloques libres del montculo far con un valor constante.
estadoheap = farheapfillfree(X);
void farfree(void far *b);
Funciones relacionadas: farheapcheckfree, farheapchecknode,

farheapwalk, heapfillfree, heapwalk.
Libera la memoria apuntada por b.

farfree(arraygrande);
Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.
farheapwalk
#include <alloc.h>
int farheapwalk(struct farheapinfo *m);

farheapcheck
#include <alloc.h>
int farheapcheck(void);
Verifica la consistencia del montculo (heap) far.
Obtiene informacin sobre las entradas en el montculo (heap) far.

struct farheapinfo heap_entry;
estadopila = farheapwalk(&heap_entry);
estadoheap = farheapcheck();
farmalloc
Funciones relacionadas: farheapcheckfree, farheapchecknode,

farheapwalk, heapfillfree, heapwalk, heapcheck.
void far *farmalloc(unsigned long n);
farheapcheckfree
#include <alloc.h>
int farheapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montculo (heap) far.

estadoheap = farheapcheckfree(F);
#include <alloc.h>
Asigna n bytes de memoria far. La cantidad completa de memoria

encima de la pila est disponible para asignacin por farmalloc. El tamao
del bloque puede exceder de 64 Kb.
if(bloquegrande = farmalloc(80000L) == NULL
printf(Asignacin fallada\n);
Funciones relacionadas: calloc, farfree, farcalloc, malloc.
618
farrealloc
#include <alloc.h>
void far *farrealloc(void far *b, unsigned long n)
Se utiliza para reasignar (ajustar el tamao de un bloque de memoria b,

al cual se ha asignado una longitud de n bytes).
heapcheckfree
#include <alloc.h>
int heapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montculo (heap).

estadoheap = heapcheckfree(N);
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL

printf(Fallo reasignacin memoria\n);
Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.
Funciones relacionadas: calloc, farcalloc, farfree, malloc.

heapchecknode
free
#include<alloc.h>
#include <stdlib.h>
#include <alloc.h>
int heapchecknode(void *n);
Verifica la consistencia de un solo nodo (bloque de memoria). Verifica

el bloque de memoria identificado por el puntero n.
vid free(void *dir_memoria);
La funcin free() libera un bloque de memoria. El argumento

dir_memoria apunta a un bloque de memoria previamente asignado a
travs de una llamada a calloc, malloc o realloc. Despus de la llama-
estadopila = heapchecknode(array);
da el bloque libre est disponible para asignacin.
free, heapfillfree, heapwalk.
char *cad;
// asignar memoria para cadena
cad = (char *) malloc(50);
heapfillfree
Funciones relacionadas: farheapchecknode, heapcheck, heapcheck-
#include <alloc.h>
int heapfillfree(unsigned int f);

...
free(cad); // liberar memoria
Funciones relacionadas: calloc, malloc, realloc
Rellena cada byte de todos los bloques de memoria no utilizados en el

montculo con un valor de carcter especificado. En Visual C++ la funcin
equivalente es heapset.
estadopila = heapfillfree(Z);
heapcheck
#include <alloc.h>
Funciones relacionadas: farheapfillfree, heapcheck, heapcheck-
int heapcheck(void);
free, heapwalk.
Verifica la consistencia del montculo (heap). En Visual C++ 6.0 la funcin equivalente es _heapcheck();
heapwalk
estadoheap = heapcheck();
int heapwalk(struct heapinfo *i);
Funciones relacionadas: heapcheckfree, heapchecknode, heapfill-
Se utiliza para obtener informacin sobre las entradas en el montculo

(heap). La funcin equivalente en Visual C++ es _heapwalk.
free, heapwalk, farheapcheck.
#include <alloc.h>
struct heapinfo i;
estadoheap = heapwalk(&i);
setblock
Funciones relacionadas: farheapwalk, heapcheck.
int
619
#include <alloc.h>
setblock(unsigned seg, unsigned n);
Ajusta el tamao de un bloque de memoria asignado anteriormente por

malloc
#include <stdlib.h>
#include <alloc.h>
allocmen. Esta funcin llama a la funcin 4Ah de DOS para ampliar el

tamao de un bloque de memoria previamente asignado por allocmen. En
las versiones Visual C++ la funcin equivalente es _dos_setblock.
void *malloc (size_t n);
Asigna memoria a bloques en el montculo. Devuelve un puntero, que

es la direccin inicial de la memoria asignada.
cadena = malloc(MAX_CHR)
F.3.
FUNCIONES DE BSQUEDA Y ORDENACIN
La mayora de los programas requieren casi siempre alguna operacin de

clasificacin y bsqueda de elementos en arrays. Borland C++ incluye diferentes funciones que realizan estas tareas.
Funciones relacionadas: calloc, free, realloc.

bsearch()
realloc
void
#include <alloc.h>
#include <stdlib.h>
*realloc(void *b, size_t n);
Ajusta el tamao de un bloque de memoria b asignado por malloc o

calloc a un tamao de n bytes. Devuelve un puntero void al bloque de
memoria reasignado.
Nuevo_buffer = realloc(viejo_buffer, long+100);
Funciones relacionadas: calloc, free, malloc.
sbrk
#include <alloc.h>
void *sbrk(int n);
Se utiliza sbrk para indicar el valor break de un proceso. El valor

break es la direccin del primer byte disponible en el segmento de datos por
omisin, ms all del segmento de datos que est siendo utilizado por los
datos en el proceso.
#include <stdlib.h>
void bsearch(const void*k, const void *b, size_t n, size_t a,

int(*comparar)(const void*, const void*));
La funcin bsearch realiza una bsqueda binaria en un array ordenado b, de n elementos, cada uno de a bytes de tamao. El argumento k apunta al valor que se est buscando. bearch devuelve un puntero (la direccin)
a la primera aparicin del valor k en el array. Si no se encuentra el valor,
bsearch devuelve o.
El argumento comparar proporciona la direccin de una rutina que
aceptar dos argumentos elem1 y elem2, cada uno un puntero a un elemento del array. La funcin comparar compara cada uno de los elementos apuntados y devuelve un valor de acuerdo con la tabla siguiente:
Valor devuelto
Condicin
Negativo
Primer elemento menor que el segundo (elem1) (elem2).
Cero
Los dos elementos son idnticos.
Positivo
Primer elemento mayor que el segundo.
sbr(500);
La bsqueda binaria requiere que el array est ordenado, por lo cual,

caso de que no est ordenado el array, se puede utilizar la funcin qsort
para ordenar el array antes de llamar a bsearch.
Funciones relacionadas: brk, coreleft
Funciones relacionadas: lfind, lsearch, qsort.
620
lfind
#include <stdlib.h>
void * lfind(const void k, const void *b, size_t *num, size_t

anchura, int(*comparar)(const void*, const void*));
La funcin lfind() realiza una bsqueda lineal de valor de k (clave) en

un array de un nmero especfico de elementos, cada uno de un nmero 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 <stdlib.h>
Funciones relacionadas: bsearch, lfind, qsort.
Condicin
Negativo
Primer elemento (elem1) menor que el segundo (elem2).
Cero
Los dos elementos son idnticos.
Positivo
Primer elemento mayor que el segundo.
Ordenar la lista de enteros y visualizar el resultado.

#include <stdlib.h>
#include <stdio.h>
int comparar(const void*, const void *);
int numeros[10] = {4,5,7,3,12,8,6,1,0,2};
main(void)
{
int i;
void * lsearch(const void *k, const void *a, size_t *n, size_t W,
int(*comparar) (const void*, const void *));
La funcin lsearch realiza una bsqueda lineal de la clave k. El

array a contiene n elementos de anchura W. La funcin comparar se utiliza para comparar la clave con el elemento actual del array. Al contrario
que bsearch(), en la funcin 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 aade al array con un valor de k.
La diferencia entre lsearch() y lfind() es que lsearch() aadir
un registro al final del array con un valor de la clave si ese registro no se ha
encontrado en el array.
Valor devuelto
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.

qsort
#include <stdlib.h>
void qsort(void a, size_t n, size_t w, int(*comparar) (const void*,

const void*));
La funcin qsort ordena un array con un nmero dado de elementos

utilizando el mtodo de ordenacin rpida quicksort (creado por C.A.R.
Hoare). El nmero de elementos de array es n y el tamao (en bytes) de cada
elemento es w. La funcin comparar se utiliza para comparar un elemento
del array con la clave; devuelve los siguientes valores:
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 notacin
el final de una cadena en C se representa por un byte que contiene un carcter
nulo (\0). Las cadenas pueden ser declaradas como arrays de caracteres.
char cad[20], cad 5[] = Hola Mortimer;
Acceso a las cadenas
strchr
A las cadenas se accede directamente a travs de su ndice, como en el

ejemplo anterior, o bien a travs de un puntero.
char *strchr(const char *cad, int c);
621
#include <string.h>
strchr() encuentra la primera aparicin de c en cad y devuelve un

puntero a la primera aparicin de c en cad. Si c no se encuentra, devuelve
un cero (NULL).
char cad5[] = Hola Mortimer;

char *p_cad5;
p_cad5 = cad5;
printf(%s, strchr(Salario mensual = $85725, $));
Se puede tambin declarar e inicializar una cadena a la vez:

char *p_cad5 = Hola Mortimer;
El archivo de cabecera <string.h> contiene numerosas funciones que

manipulan cadenas.
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 aparicin de a.

stpcpy
#include <string.h>
strcmp
#include <string.h>
char *stpcpy(char *cad1, const char *cad2);
La funcin 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);
Compara una cadena con otra. Los resultados seran:

> 0 si a > b
= 0 si a == b
< 0 si a < b
Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.

strcat
int strcmp(const char *a, const char *b);
#include <string.h>
char *strcat(char *cad1, const char cad2);

strcat() concatena (aade) cad1 al final de cad2, terminando la cadena resultante con un carcter nulo (\0).
char nombre[80] = Bob;
char blanco[2] = ;
char ultimo[80] = Marley;
...
strcat(nombre,blanco);
// blanco se concatena a nombre
strcat(nombre,ultimo);
// ultimo se concatena a nombre
// la cadena nombre ser Bob Marley
Funciones relacionadas: strcpy, strdup, strncat, strncpy.
i = strcmp(MNP, mnp);
i = strcmp(abc, abc);
i = strcmp(xy, abc);
// resultado < 0
// resultado = 0
// resultado > 0
char s1[80] Mayo;

char s2[80] = Octubre;
int j;
j = strcmp(s1, s2);
Funciones relacionadas: strcmpi, stricmp, strnicmp, strncmp.
strcmpi
#include <string.h>
int strcmpi(const char *cad1, const char * call2);
Compara una cadena con otra sin diferenciar entre maysculas y minsculas y devuelve un entero:
622
< 0 si cad1 < cad2

= 0 si cad1 = cad2
> 0 si cad1 > cad2
ce del primer carcter de cad1, que pertenece al conjunto de caracteres de

cad2.
v = strcmpi(c1, c2);
primero = strcspn(circunloquio, q);

// primero = 8
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.

strcoll
#include <string.h>
int strcoll(const char *cad1, const char cad2);
Compara cad1 con cad2. Devuelve un valor.
Funciones relacionadas: strpbrk, strspn.

strdup
#include <string.h>
char * strdup(const char *cad);
Asigna memoria y copia una cadena dada en ese espacio. En realidad,

strdup() llama a malloc para asignar suficiente memoria para contener a
cad. Si falla la asignacin de memoria, strdup() devuelve un carcter nulo
(NULL).
< 0 si cad1 < cad2

= 0 si cad1 = cad2
> 0 si cad1 > cad2
Leer una cadena y hacer un duplicado.

if(strcoll(nombre1, nombre2)! = 0)
exit(EXIT_FAILURE);
Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp,

strxfrm.
strcpy()
#include <string.h>
char *strcpy(char *cad1, const char *cad2);
#include <stdio.h>
#include <string.h>
main()
{
char cad1[80], * cad1_copia;
printf(Introduzca una cadena:);
gets(cad1);
cad1_copia = strdup(cad1);
printf(La cadena duplicada es:%s\n, cad1_copia);
return 0;
}
strcpy() copia cad2 en cad1. Si la longitud de la cadena resultante

excede el tamao asignado a cad1, puede producir fallos en el programa.
strerror
char *a = Pepe Luis;

char b[12];
strcpy(b, a);
cout << b << \n;
char *strerror(int errnum);
Funciones relacionadas: strcat, strcup, strncat, strncpy.

strcspn
#include <string.h>
#include <string.h>
size_strcspn(const char *cad1, const char *cad2);
Localiza la posicin de la primera aparicin en una cadena de cualquier

carcter de otra cadena. Si tiene xito, la funcin strcspn devuelve el ndi-
Obtiene el mensaje de error del sistema correspondiente al nmero dado

en el argumento errnum. La funcin strerror() obtiene el mensaje de
error del sistema utilizando el valor en la variable global errno, como el
ndice una tabla de errores denominadas sys_errlist, que est declarado
en el archivo de cabecera stdlib.h.
errno = 0;
printf (Error, strerror(errno);
Funciones relacionadas: perror, _strerror.
strerror
#include <string.h>
#include stdio.h
strlwr
char
623
#include <string.h>
*strlwr(char *cad);
char *strerror(const char *cad);
Esta funcin sirve para generar un mensaje de error definido por el

usuario.
Convierte una cadena en letras minsculas. La funcin devuelve un

puntero a la cadena convertida.
printf(%S, _strerror(error apertura archivo));
char *orden =SALIR;

strlwr(orden);
// ahora orden = salir;
Funciones relacionadas: perror, strerror.
Funciones relacionadas: strupr, toloweer.
stricmp
#include <string.h>
strncat
#include <string.h>
it stricmp(const char *cad1, const char *cad2);
char *strncat(char *cad1, const char *cad2, size_t n);
Esta funcin se utiliza para comparar una cadena a otra sin tener en
cuenta el tamao de las letras. Convierte todos los caracteres alfabticos de
cad1 y cad2 en minsculas; a continuacin, se comparan las dos cadenas y
devuelve un valor entero que indica el orden lexicogrfico de cad1 con respecto a cad2.
La funcin strncat() aade los primeros n caracteres de cad2 a cad1,

y termina la cadena resultante un carcter 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.
Si cad1 = cad2
Si cad1 < cad2
Si cad1 > cad2
el valor de la funcin es cero.

el valor de la funcin es menor que cero.
el valor de la funcin es mayor que cero.
Resultado = stricmp(cad1, cad2),
char *a = Sierra Madre;

char *b = de la ciudad de Monterrey;
cout << strncat(a, b, 4) << \n;
cout << strncat(a, b) << \n;
Funciones relacionadas: strcat, strdup, strcpy, strncpy.
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.

strncmp
strlen
#include <strign.h>
size_t strlen(const char *cad);
Proporciona la longitud de una cadena cad. El carcter nulo no se incluye en la longitud; en consecuencia, cuando reserve espacio, recuerde aadir
1 al valor devuelto por strlen.
longitud = strlen(nombre);
char s[81] = Cadena demo;
printf(La longitud de s es:%d\n strlen(s));
Funciones relacionadas: _fstrlen.
#include <string.h>
int strncmp(const char *cad1, const char *cad2, size_t n);
Compara un nmero especificado en caracteres de dos cadenas y

devuelve un entero con un valor.
< 0 si cad1 < cad2
= 0 si cad1 < cad2
> 0 si cad1 < cad2
char *a = Mortimer el andaluz;
char *b = Mortimer el mexicano;
if((strncmp(a, b, 8)) == 0)
624
cout << Ambas cadenas comienzan con \Mortimer\;

else
cout << Estas cadenas no comienzan con \Mortimer\;
Encuentra la ltima aparicin del carcter c en cad. Devuelve un punteo a la ltima aparicin de c o un carcter nulo si c no est en cad.
Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, str-
char *nombrearch = c: /usr/tst/libro/cap1.txt;

cout << (strrchr(nombrearch, /)+1 << \n;
nicmp.
Funciones relacionadas: strchr.

strnset
#include <string.h>
char *strnset(char *cad, int c, size_t n);
strrev
Inicializa los caracteres de una cadena a un valor dado (blanco u otro

carcter). Devuelve un puntero a la cadena cad. El carcter c se utiliza para
rellenar la cadena con ese carcter; n es el nmero de posiciones de caracteres que se han de inicializar.
char *strrev(char *cad);

gets(cadena);
printf(Introducir un carcter:);
c = getche();
long = strlen(cadena)/2;
strnset(cadena, c, lon);
Funciones relacionadas: memset, setmem, strset.
strpbrk
#include <string.h>
char *strpbrk(const char *cad1, const char *cad2);
Encuentra la primera aparicin en cad1 de cualquiera de los caracteres

de cad2. El carcter nulo no se incluye en la bsqueda. Si el carcter no
existe, se devuelve un carcter nulo (NULL).
#include <string.h>
Invierte los caracteres de la cadena cad. El carcter de terminacin nulo

permanece en el mismo lugar. strrev() devuelve un puntero a la cadena
inversa.
Aplicacin: Invertir una cadena leda del teclado e imprimir el resultado.
#include <stdio.h>
#include <string.h>
main()
{
char demo[80]
gets(demo);
strrev(demo);
printf(La cadena inversa es:\n %s |\n, demo);
return 0;
}
Funciones relacionadas: strcpy, strncpy.
strset
#include <string.h>
char *s = Mortimer L.J. Mackoy;

char *p = strpbrk(s, L4);
cout << p << \n;
// la salida es L.J.Mackoy
char *strset(char *cad, int c);
Funciones relacionadas: strchr, strcspn.
Establece todos los caracteres de la cadena cad al valor de c. Termina

cuando se encuentra el primer carcter nulo. Devuelve un puntero a la cadena modificada.
strrchr
char *strrchr(const char *cad, int c);
#include <string.h>
char *cad = -----;

strset (cad, x);
// cad es ahora xxxxx
Funciones relacionadas: strnset.
strspn
#include <string.h>
sze_t strspn(const char *cad1, constchar *cad2);
625
Convierte cualquier letra minscula de la cadena en mayscula y

devuelve un puntero a la cadena convertida (slo alfabeto ingls).
La funcin strupr y su homnima strlwr no forman parte de la biblioteca ANSI C. En estos casos, utilice las funciones toupper y tolower.
Localiza la posicin del primer carcter de una cadena (cad1) que no

pertenece al conjunto de caracteres de otra (cad2).
strupr(sierra madre);
loc = strspn (cad1, blanco);
Funciones relacionadas: strlwr, toupper.
// SIERRA MADRE
Funciones relacionadas: strcmp, strcspn.

strxfrm
strstr
#include <string.h>
char *strstr(const char *cad1, const char *cad2);
Localiza la primera aparicin de una cadena en otra. Si tiene xito, la

funcin strstr devuelve un puntero a la primera aparicin de cad2 como
una subcadena de cad1. Si la bsqueda falla, se devuelve NULL.
char *s = Mi autor favorito es Octavio Paz
char *a = Octavio Paz;
cout << La subcadena << a << se encuentra:
<< strstr(s, a) << \n;
Funciones relacionadas: strchr, strcspn, strpbrk

strtok
#include <string.h>
#include <string.h>
size_t strxfrm(char *cad1, char *cad2, size_t n);
Convierte cad2 en cad1 basado en informacin especfica local y con

un nmero mximo de caracteres a situar en cad1 de n. En el siguiente
ejemplo, strxfrm transforma los tres primeros caracteres de cad1 en los
tres primeros caracteres de cad2.
char *cad1 = abcdefg;
char *cad2 = 1234567;
clrscr();
strxfrm(cad1, cad2, 3);
printf(Transformada: %s\n, cad1);
F.5.
FUNCIONES DE CLASIFICACIN
DE CARACTERES
char *strtok(char *cad1, const char *cad2);
Rompe una cadena en subcadenas (token) utilizando una lista de separadores. Devuelve un puntero a la subcadena actual y un NULL cuando se
alcanza el final de la cadena.
char
char
cout
cout
*s
*t
<<
<<
= Prefiere a Verdi, o a Pucini?;

= .,!* ;
strtok(s, t) << \n;
strtok(NULL, !);
Funciones relacionadas: strpbrk, strcspn.
strupr
char *strupr(char *cad);
#include <string.h>
C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita determinar la categora de un carcter o convertir un carcter de maysculas en
minsculas, o viceversa. La biblioteca C contiene funciones que pueden ser
definidas como macros para estos propsitos. Las macros estn definidas en
el archivo de cabecera ctype.h.
Las macros de clasificacin sirven para determinar qu clase de valor
contiene una variable carcter. Puede necesitar conocer esta caracterstica
para identificar ciertas clases de caracteres. Por ejemplo, si su programa
pide al usuario que teclee un nmero, pero el usuario teclea en su lugar
una letra, ser preciso capturar el error. Otro caso es cuando desea imprimir
un archivo, y necesita asegurarse de que el archivo contiene slo caracteres
imprimibles, en caso de que desee que su programa acepte caracteres de
control, necesita saber cundo pulsa el usuario un carcter de control. En
resumen, cada vez que necesite identificar el tipo de tecla que ha pulsado el
usuario, se pueden utilizar las macros de clasificacin.
626
Asimismo, existen otras funciones en el archivo ctype.h que sirven

para convertir caracteres en maysculas en minsculas, y viceversa; y valores enteros en cdigos ASCII.
iscntrl, isdigit
isgraph, islower
isprint, ispunct, isspace
isupper,isxdigit
isalnum
int
int
int
int
int
int
int
int
int
#include <ctype.h>
int isalnum(int c);
La funcin isalnum() devuelve un cero si c es un carcter no alfanumrico y un valor distinto de cero si el carcter es alfanumrico.
carac = getch();
if(isalnum(carac))
printf(%c letra|digito \n, carac);
else
printf(%c no letra|digito \n, carac);
Funciones relacionadas: isascii.

isalpha
#include <ctype.h>
int isalpha(int c);
La funcin isalpha() verifica si un carcter es alfabtico. Devuelve un

valor distinto de cero si c es un carcter alfabtico, o 0 si c no es alfabtico.
int c = getah()
if(isalpha) printf(%c es letra\n, c);
Funciones relacionadas: iascii.

isascii
#include <ctype.h>
iscntrl(int c);
isdigit(int c);
isgraph(int c);
islower(int c);
isprint(int c);
ispunct(int c);
isspace(int c);
isupper(int c);
isxdigit(int c);
Estas macros sirven para determinar propiedades especficas de un

carcter ASCII.
Macro
Verifica
Rango vlido de valores
iscntrl
isdigit
isgraph
islower
isprint
ispunct
Carcter de control.
Dgito decimal.
Carcter imprimible (sin espacio).
Carcter minscula.
Carcter imprimible
Carcter puntuacin
isspace
isupper
isxdigit
Carcter blanco.
Carcter mayscula.
Dgito hexadecimal.
0..1Fh, 7Fh
0..9
21h a 7Eh
a..z
20h..7Eh
21h..2Fh, 3Ah..40h,
5Bh..60h, 7Bh..7Eh
9h..Dh 0 20h (blanco)
A..Z
0..9
A..F
a.. f
#include ctype.h>
int isascii(int c);
Comprueba si un carcter c es un carcter ASCII; c est en el rango 0-127.

Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII.
Cada macro (funcin) devuelve un valor distinto de cero si c satisface

el criterio de esa macro; en caso contrario, devuelve un cero.
carac = getch();
if(isascii(carac))
printf(%c es ASCII \n, carac);
else
printf(%c no es ASCII \n, carac);
if(isprint(c))
if(iscntrl(c))
if(isdigit(c))
if(islower(c))
Funciones relacionadas: toascii, isalnum, isdigit,
printf(\n
printf(%c
printf(%c
printf(%c
%c
es
es
es
imprimible\n, c);
un carcter de control\, c);
un dgito\n, c);
letra minscula\n, c)
toascii
#include <ctype.h>
int toascii(int c);
Esta funcin convierte un valor entero en un carcter ASCII vlido.
F.6.
627
FUNCIONES DE CALENDARIO (FECHA Y HORA)
Las funciones de calendario (fecha y hora) permiten obtener la hora actual

y, a continuacin, convertirla y almacenarla de acuerdo a sus necesidades
particulares. La hora actual se toma siempre de la hora del sistema. Las funciones de calendario estn incluidas en el archivo de cabecera time.h.
C = toascii(entero);
asctime
#include <time.h>
char *asctime(const struct tm *hora);

_tolower
tolower
#include <ctype.h>
int _tolower(int c);

int tolower(int c);
Convierte un carcter mayscula en minscula. Utilice _tolower slo

cuando est seguro de que el carcter que quiere convertir es una letra
mayscula.
La funcin _tolower() slo est disponible en sistemas UNIX. Por
consiguiente, para asegurar la compatibilidad utilice slo la funcin tolower().
c = tolower(S);
// c se convierte en S
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
{
int
int
int
int
int
int
int
int
int
};
tm
tm_sec;
tm_min;
tm_hour;
tm_mday;
tm_mon;
tm_year;
tm_wday;
tm_yday;
tm_isdst;
//
//
//
//
//
//
//
//
//
[0,59], segundos
[0,59], minutos
[0,23], horas
[1,31], dias del mes
[0,11], mes del ao
[desde 1900], ao
[0,6], dias desde domingo
[0,265], numero dia ao
indicador hora de verano
Funciones relacionadas: iascii, _toupper, toupper.

printf(Fecha/hora es %s\n, asctime(&reloj));
Funciones relacionadas: ctime, gmtime, clocaltime, strftime,
_toupper
touper
#include <ctype.h>
int _toupper(int c);

int _toupper(int c);
int c;
// carcter a convertir
time.
clock
#include <time.h>
cock_t clock(void);
Estas funciones convierten un carcter minscula en mayscula. Utilice _toupper slo cuando est seguro de que el carcter que quiere convertir es una letra minscula (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.
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
ctime
#include <time.h>
ftime
#include <sys/timeb.h>
char *ctime(const time_t *hora);
void
Convierte la fecha y hora almacenada como valor de tipo time_t en una

cadena de caracteres (mes da hora ao\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));
struct timeb {
long time;
short millitm;
short timezone;
Funciones relacionadas: asctime, ftime, strtime, time.
ftime(struct timeb *ptrhora);
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
double
#include <time.h>
difftime(time_t hora2, time_t hora1);
Obtiene la diferencia entre dos tiempos en segundos.

time_t inicio, fin
clrscrl();
inicio = time(NULL);
delay (5000);
fin = time(NULL);
printf(Diferencia en segundos: %f\n,
difftime(inicio, fin));
Funciones relacionadas: time tzset.

getdate
#include <dos.h>
void getdate(struct date *f);
Obtiene la fecha del sistema. Los componentes se almacenan en la

estructura date definida en dos.h.
Funciones relacionadas: asctime, ctime, gmtime, localtime,

tzset.
dostounix
ftime(&hora);
#include <dos.h>
struct date {
int da_year;
char da_day;
char da_mon;
};
// ao actual (1980-2099)
// dia mes (1-31)
// mes (1-12)
struct date fecha;

getdate(&fecha);
long dostounix(struct date *f, struct time *h);
Funciones relacionadas: dostounix, gettime, setdate, settime.
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en

formato UNIX.
gettime
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.
#include <dos.h>
void gettime(struct time *t);
Obtiene la hora actual del sistema. Los componentes de la hora se almacenan en la estructura time definida en dos.h.
struct time {
unsigned char ti_min
// minutos (0-59)
unsigned char ti_hour

unsigned char ti_hund
unsigned char ti_sec
// horas (0-23)
// centsimas de segundo (0-99)
// segundos (0-59)
setdate
629
#include <dos.h>
};
void setdate(struct date *f);
struct time hora;

gettime(&hora);
Cambia la fecha actual del sistema. Los componentes de la fecha (da,

mes. Ao) se especifican en los campos de la estructura date.
Funciones relacionadas: dostounix, getdate, setdate, settime.
struct date {
int da_year;
char da_day;
char da_mon;
};
gmtime
#include <time.h>
struct tm *gmtime (const time_t *hora);
Convierte la fecha y hora en el tiempo medio de Greenwich (GMT)

(ao, mes, da, hora, minutos, segundos y otros campos). Vase struct tm
en asctime.
// ao actual
// da mes
// mes, 1 para enero, 2...
En Visual C++ la funcin equivalente es _dos_setdate.

setdate(&fecha);
Funciones relacionadas: getdate, gettime, settime, dostounix.
ahora = gmtime(&hoy);
settime
#include <dos.h>
Funciones relacionadas: asctime, ctime, ftime, localtime, time.

void settime(struct time *h);
localtime
#include <time.h>
Cambia la hora actual del sistema. Los componentes de la hora hora,

minutos y segundos se deben cargar en los campos apropiados de la
estructura time definida en dos.h. Vase gettime.
struct tm *localtime(const time_t *hora);

settime(&hora);
Convierte una fecha y hora en varios campos de una estructura de tipo

tm. Vase struct tm en asctime.
Funciones relacionadas: dostounix, gatdate, gettime, setdate.
tiempoactual = localtime(&ahora);
Funciones relacionadas: asctime, gmtime, time.
stime
#include <time.h>
int stime(time_t *t);

mktime
#include <time.h>
time_t mktime(struct tm *h);
Establece la fecha y hora del sistema al valor contenido en la posicin

cuya direccin est en el argumento t.
asctime.
time_t horasis;
horasis = time(NULL);
stime(&horasis);
printf(segundos desde 1/1/70 %ld, horasis);
Funciones relacionadas: asctime, gmtime, localtime, time.
Funciones relacionadas: dostounix.
Convierte la hora local a un valor de calendario. Vase struct tm en
630
strftime
#include <time.h>
size_t strftime(char *cad, size_t maxlon,

const char *formato, const struct tm *t);
Convierte a formato DOS un valor de hora en el formato UNIX.

tnixtodos(t_unix, &d_dos, ft_dos);
Funciones relacionadas: getdate, gettime, time, setdate, settime.

Convierte un puntero en una estructura tm en una cadena cad (con una
longitud mxima de n), utilizando f para dar formato a la cadena. El formato es similar a printf().
horaseg = time(NULL);
horaactual = localtime(&horaseg);
strftime(buffer, 80, %A %B %d 19%y:I:%M, horaactual);
Funciones relacionadas: asctime, ctime, gmtime, localtime,

time.
time
F.7.
FUNCIONES DE CONTROL DE DIRECTORIOS
MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerrquico 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 manipulacin de directorios residen en el archivo de cabecera dir.h.
#include <time.h>
chdir
#include <dir.h>
time_t time(time_t *h);

int chdir(const char *camino);
Proporciona el tiempo del sistema en segundos desde las 00:00:00 de

1/1/1970 tiempo GMT.
time(&hora);
tzset
void
#include <time.h>
tzset(void);
Establece las variables de entorno horarios TZ; asigna valores a las

variables globales timezone, daylight y tzname.
Cambia el directorio de trabajo actual al directorio especificado en el

argumento camino. La funcin 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.
tzset();
printf(Luz de verano = %d\n, daylight);
printf(zona horario = %ld\n, timezone);
findfirst
Funciones relacionadas: asctime, ftime, gmtime, localtime,
int findfirst(const char *camino, struct ffblk *ffblk, int atrib);
time.
unixtodos
void
#include <time.h>
unixtodos(long time, struct date *f, struct time *h);
#include <dir.h>
Busca en un directorio de disco hasta encontrar el primer archivo cuyo

nombre y atributos se corresponden con los valores especificados. El formato de la estructura ffblk es:
struct ffblk {
char ff_reserved[21];
// reservada por DOS
char ff_atrib;
int ff_ftime;
int ff_date;
long ff_fsize;
char ff_name[13];
//
//
//
//
//
encontrado atributo
hora archivo
fecha archivo
tamao archivo
encontrado nombre de archivo
fnsplit
631
#include <dir.h>
void fnsplit(const char *camino, char *u, char *dir,

char *nombrearch, char *ext);
};
La variable attrib viene definida en el archivo de cabecera <dos.h> y

puede ser igual a uno de estos valores:
FA_RDONLY
FA_HIDDEN
FA_SYSTEM
FA_LABEL
FA_DIREC
FA_ARCH
Archivo de slo lectura.

Archivo oculto.
Archivo del sistema.
Etiqueta de volumen.
Directorio.
Bit de archivo activado.
h = fnsplit(camino, unidad, dir, nomarch, ext);
Funciones relacionadas: fnmerge.
getcurdir
struct ffblk ffblk;

int t;
t = findfirst(*.*, &ffblk,0);
#include <dir.h>
int getcurdir(int u, char *dir);
Funciones relacionadas: findnext.

findnext
Separa un nombre de camino completo en sus componentes: letra de la

unidad (u), camino del directorio, nombre del archivo y extensin del archivo (ext).
#include <dir.h>
int findnext(struct ffblk *ffblk);
Obtiene el directorio de trabajo actual en una unidad especfica. El

nmero de la unidad (u) 0 indica la unidad actual por omisin, 1 significa
unidad A, 2 unidad B, etc. La funcin devuelve un cero si tiene xito, en
caso de error devuelve 1.
getcurdir(3, cuentas);
findnext contina la bsqueda de findfirst(). findnext llama a

la funcin 4Fh de DOS para encontrar el siguiente archivo cuyo nombre y
atributos son idnticos a los dados en la llamada a la funcin findfirst().
Funciones relacionadas: getcwd, getdisk.
findnext(&filefinfo);
getcwd
#include <dir.h>
Funciones relacionadas: findfirst.

char *getcwd(char *camino, int numcar);
fnmerge
#include <dir.h>
void fnmerge(char *camino, const char *u, const char *dir,

const *nombrearch, const char *ext);
Crea un nombre de camino completo compuesto de una letra de la unidad (u), camino del directorio (dir), nombre de archivo (nombrearch) y
extensin del archivo (ext).
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 mximo nmero de caracteres que el buffer camino puede contener. La funcin getcwd es til para obtener el nombre del directorio actual
y guardarlo. Si su programa cambia los directorios de trabajo durante su ejecucin, puede utilizar el nombre guardado para restaurar el directorio de trabajo actual antes de terminar.
fnmerge(camino, c:, \\aux\\,demo,.dat);
getcwd(cuentas, 80)
Funciones relacionadas: fnsplit.
Funciones relacionadas: chdir.
632
getdisk
#include <dir.h>
Funciones relacionadas: chdir, rmdir.
int getdisk(void);
mktemp
La funcin getdisk obtiene el valor entero que representa la unidad

actual (0, unidad A; 1, unidad B...)
#include <dir.h>
char *mktemp(char *plantilla);
Crea un nombre de archivo a partir de una plantilla. Devuelve un puntero al nombre del archivo si tiene xito y nulo en caso de error.
int unidad;
clscr();
unidad = getdisk();
mktemp(nombre);
Funciones relacionadas: setdisk.

mdir
#include <dir.h>
searchpath
#include <dir.h>
int rmdir(const char *camino);
char searchpath(const char *nombre);
Elimina el directorio escrito por la variable camino, siempre que el

directorio est vaco, no sea el directorio raz y no sea el directorio de trabajo rmdir(); devuelve 0 si la operacin 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:
Busca un archivo especfico 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.
Permiso denegado.
Camino archivo no encontrado.
Esta funcin es similar a RMDIR o RD de MS-DOS.
EACCES
ENOENT
rmdir(C:\\PRUEBAS); Supresin de directorio PRUEBAS
#include <dir.h>
int mkdir(const char *camino);
Crea un directorio con un nombre de camino especificado. Funciona

igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha
creado con xito o 1 si se produce un error; en este caso, la variable global
errno toma el valor EACCES (permiso denegado) o ENOENT (nombre de
camino no vlido).
EACCES
ENOENT
Permiso denegado.
Camino no encontrado.
resultado = mkdir(PRUEBAS);
// crea el directorio PRUEBAS
Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la

variable de entorno PATH.
buffer = searchpath(autoexec.bat);
Funciones relacionadas: getenv, putenv.
Funciones relacionadas: chdir, mkdir.

mkdir
buffer = searchpath(BC.EXE);
setdisk
#include <dir.h>
int setdisk(int unidad);
Cambia a una nueva unidad por omisin. El valor de la unidad (unidad)

es un entero.
Unidad A
B:
C:
D:
...
nuevaunidad = setdisk(3);
Funciones relacionadas: getdisk
/ nueva unidad actual es C:
F.8.
FUNCIONES DE CONTROL DE PROCESOS
Un proceso es un programa ejecutable en memoria y su entorno asociado.

Cada vez que se ejecuta un programa se crea un proceso.
En resumen, un proceso es un programa que se est ejecutando por el
sistema operativo. Consta del cdigo del programa y de datos, adems de
informacin relativa al proceso, tales como nmero 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 mayora 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.
atexit
633
#include <stdlib.h>
int atexit(void(*func)(void));
Procesa la funcin especificada al salir.

atexit(segundo);
Funciones relacionadas: abort, exit, _exit.
exec(familia)
#include <process.h>
int excel(char *camino, char *arg0,...,NULL);

int execle(char *camino, char *arg0,..., *argn, NULL, char **env);
int execlp(char *camino, char *arg0, arg1,...,NULL);
abort
#include <stdlib.h>
int execlpe(char *camino, char *arg0,...argn, NULL, char **env);

int execv(char *camino, char argv[]);
int execve(char *camino, char argv[], char **env);
void abort(void);
Termina la ejecucin del programa actual y devuelve un cdigo de

error (3).
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 cdigo del programa. Las funciones exec crean un proceso hijo que
carga y ejecuta el programa especificado por el argumento camino.
if (argc 1) {
printf(Faltan argumentos!\n)
abort()
}
Funciones relacionadas : exit, _exit, raise, signal, spaw.
execlo(hijo.exe, hijo.exe, Uno, Dos, NULL);

execv(hijo.exe, argv);
Funciones relacionadas: abort, atexit, exit, _exit, fpreset, spawn.

assert
#include <assert.h>
void assert(int expresin);
Imprime un mensaje de error e interrumpe el programa si expresin es

falsa (0).
exit
void
#include <stdlib.h>
exit(int estado);
assert(string != NULL;
assert(*string != \0);
assert(strlen(string) < 2);
Termina un programa. Antes de terminar, se cierran todos los archivos,

se escribe la salida a travs del buffer y se llama a cualquier funcin exit
registrada. estado representa el estado de salida del programa; 0, salida
normal; distinto de cero, indica un error.
Funciones relacionadas: abort, raise, signal.
exit(0);
634
Funciones relacionadas: abort, atexit, exit, exit, fpreset,

spawn, system.
Obtiene informacin detallada sobre formatos monetarios y numricos

de diferentes pases.
p_lconv = localeconv();
_exit
#include <stdlib.h>
Funciones relacionadas: setlocale.
void _exit(int estado);
Termina inmediatamente el proceso actual sin hacer otras operaciones

auxiliares (como cierre de archivos).
longjmp
#include <setjmp.h>
void longjmp(jmp_buf env, int valor);

_exit(0)
Restaura el estado de la pila y la ejecucin local anteriormente grabada

en env por setjmp.
Funciones relacionadas: exit.
longjmp(plaza, 3);
getenv
#include <stdlib.h>
Funciones relacionadas: setjmp.
char *getenv(const char *nomvar);
Obtiene la definicin 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 continuacin, busca una entrada en la lista correspondiente
a nomvar.
varlib = getenv(LIB);
Funciones relacionadas: putenv.

getpid
perror
#include <stdio.h>
void perror(const char *cadena);
Imprime un mensaje de error del sistema en el flujo stderr. El argumento cadena se imprime primero, seguido por dos puntos; a continuacin,
el mensaje de error correspondiente al valor actual de la variable global
errno y, finalmente, un carcter de nueva lnea. Si cadena es un puntero
nulo o un puntero a una cadena nula, perror imprime slo el mensaje de
error del sistema.
perror(Error de cierre de archivos);
unsigned getpid(void)
Funciones relacionadas: _strerror, strerror.
Obtiene el ID de proceso de un programa. Est disponible en sistemas

UNIX.
putenv
printf(PID:%X\n,getpid());
int putenv(const char *cadena);
Funciones relacionadas: getpsp.
Crea nuevas variables de entorno o modifica los valores de las variables

de entorno existentes.
localeconv
struct lconv *localeconv(void);
#include <locale.h>
if(putenv(argv[1] == -1)
Funciones relacionadas: getenv.
#include <stdlib.h>
raise
#include <signal.h>
int raise(int seal);
Enva una seal al programa en ejecucin. Crea una condicin de

excepcin correspondiente al nmero seal. Existen diferentes constantes,
por ejemplo, SIGABRT (terminacin anormal).
printf(prueba de raise\n);
raise(SIGABRT);
635
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.
Funciones relacionadas: abort, signal.

spawnlpe(P_WAIT, hijo.exe, hijo.exe, spawnlpe, buf,
NULL, env);
setjmp
#include <setjmp.h>
Funciones relacionadas: exec.
int setjmp(jmp_buf env);
Guarda el estado actual del programa (el entorno de la pila) antes de llamar a otra funcin. Este entorno puede ser restaurado por una llamada a
longjmp, realizando el efecto de un goto no local.
if(setjmp(env) != 0) printf(valor de longjmp\n);
Funciones relacionadas: longjmp.

signal
F.9.
FUNCIONES DE CONVERSIN DE DATOS
Las funciones de conversin de tipos de datos sirven para crear un puente de

unin entre los dos estilos de representacin de nmeros: la cadena de texto
legible por los humanos y el formato binario legible por las mquinas. Las
funciones de conversin son ideales para convertir argumentos de lneas de
rdenes de su representacin de cadena al formato interno.
#include <signal.h>
atof()
#include <math.h>
#include <stdlib.h>
void (*signal(int sig, void (*func) (int))) (int);
Establece tratamiento de seales de interrupcin. La funcin signal permite a un proceso elegir uno de los diferentes modos de manipular una seal
de interrupcin del sistema operativo.
double atof(const char *cadena);
La funcin atof() convierte el argumento cadena en un valor de doble

precisin. La cadena debe tener el siguiente formato:
signal(SIGINT, SIG_IGN);
[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]
Funciones relacionadas: abort, _control87, exit, longjmp, raise,
setjmp.
spawn (funciones)
#include <stdio.h>
int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);
opcional
blancos o
tabulaciones
e/E
dgitos decimales
La conversin termina cuando aparece el primer carcter no reconocible o cuando se encuentra un carcter nulo (\0).
636
double x;
char *cad_dbl = 200-85;
...
x = atof(cad_dbl);
La conversin de caracteres de la cadena hasta que se encuentre el primer carcter no reconocible o el carcter nulo (\0).
// convierte la cadena 200.85
a real
Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf,

strtod.
long int i;
char cad_ent = 9876543;
...
i = atol(cad_ent); // convierte cadena 9876543 a entero
// largo.
Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod,
atoi
#include <stdlib.h>
strtol, strtoul, ultoa.
int atoi (const char *cadena)
La funcin atoi() convierte el argumento cadena en un valor entero.

La cadena debe tener el siguiente formato:
[espacio en blanco][signo][ddd]
#include <stdlib.h>
char *ecvt(double valor, int n, int *dec, int *signo);
La funcin ecvt() convierte un argumento de valor doble precisin en

una cadena con n dgitos. Si valor tiene ms de n dgitos, los dgitos inferiores se truncan. dec es un puntero a un entero en donde se devuelve la
posicin del punto decimal; signo es un puntero a un entero donde se
devuelve el signo (cero, positivo; en los restantes casos, negativo).
opcional
espacio o tabulacin
ecvt
dgitos decimales
La conversin termina cuando se encuentra un carcter no reconocible

(carcter nulo, \0, punto decimal o una letra). Si no puede convertir la
cadena devuelve nulo.
p_buffer = ecvt(valor, exactitud, &dec, &signo);
Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa,

ltoa, ultoa.
int i;
char *cad_ent =123;
...
i = atoi(cad_ent);// convierte la cadena 123 al entero 123
fcvt
Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.
char *fcvt(double valor, int n, int *dec, int *signo);
atol
#include <stdlib.h>
long atol(const char *cadena);
Convierte el argumento cadena en un valor entero largo. La cadena debe

tener el formato:
#include
<stdlib.h>
Al igual que la funcin ecvt, fcvt convierte el argumento valor de

doble precisin en una cadena de n dgitos. Si el nmero de dgitos de valor
excede a n, el exceso de dgitos se trunca. Si hay menos dgitos que n la
cadena se rellena con ceros. fcvt se diferencia de ecvt en el modo de tratar los dgitos significativos. ecvt() busca un nmero total de dgitos,
mientras que fcvt() busca el nmero de dgitos a la derecha del puntero
decimal.
[espacio en blanco][signo][ddd]
cadena = fcvt(valor, exactitud, %oposicin_d, &signo);
opcional
blancos y tabulaciones
dgitos decimales
Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,

sprintf, ultoa.
gcvt
#include <stdlib.h>
char *gcvt(double valor, int ndig, char, *buf);
La funcin gcvt() convierte el argumento valor de doble precisin en

una cadena de caracteres que se almacena en el buffer cuya direccin se da
en el argumento buf. Se debe asignar bastante espacio en el buffer para contener todos los dgitos de la cadena convertida y el carcter nulo de terminacin (\0).
gcvt(valor, digitos, cadena);
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf,

sprintf, ultoa.
itoa
#include stdlib.h>
strtod
637
#include stdlib.h>
double strtod(const char *cad, char **p);
La funcin strtod() convierte la cadena cad en un valor de doble

precisin. La cadena debe tener el formato
[blanco][signo][ddd][.][exponente][signo][ddd]
+, -
d, D, e, E
blanco/
tabulacin
dgitos decimales
strtod() devuelve el valor de doble precisin y cero si no se produce la

conversin. La conversin se termina con el primer carcter no reconocible.
Aplicacin: Convertir la cadena 843899.567 a un valor de coma flotante double.
char *itoa(int valor, char *cad, int base);
#include <stdio.h>
#include <stdlib.h>
La funcin itoa() convierte el argumento entero valor en una cadena

de caracteres utilizando el argumento base, como base de un sistema de
numeracin (2 a 36). Debe existir bastante espacio en cad para contener 17
caracteres, itoa() devuelve un puntero a la cadena cad.
main()
{
double x;
char *num_flt = 843899.567:
char *p;
x = strtod(num_flt, &p);
printf(x = %f\n,x);
itoa(32, buffer, 16); // buffer contendr 20, ya que 32 entero

// equivale a 20 en hexadecimal
}
Funciones relacionadas: atoi, atol, itoa, ultoa.
ltoa
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.
#include <stdlib.h>
strtol
#include <stdlib.h>
char *ltoa(long valor, char * cad, int base);
La funcin ltoa() convierte el argumento entero largo valor en una

cadena de caracteres que utiliza el argumento base como base de un sistema de numeracin. Como un entero largo ocupa 32 bits en base 2, la cadena puede ocupar 33 bytes con el carcter nulo de terminacin. 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.
long strtol(const char *cad, char **p, int b);
La funcin 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]
+, blancos y tabulaciones
dgitos decimales
hexadecimal
octal
638
La conversin se termina con el primer carcter no reconocible. Si se

produce un error de desbordamiento (positivo o negativo) la variable errno
se establece al valor de la macro ERANGE.
Aplicacin. Convertir la cadena 9876 en valor entero.
#include <stdlib.h>
char *ultoa(unsigned long valor, char *cad, int base);
La funcin 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 cdigo de error. cad puede contener hasta 33 caracteres, excluyendo el carcter
de terminacin nulo (\0).
#include <stdio.h>
#include <stdlib.h>
main()
{
int base = 10;
long int i;
char *cad_ent = 9876;
char *ptrcad;
i = strtol(cad_ent, &ptrcad, base);
printf(i = %ld\n, i);
}
ultoa(valor, buffer, base);
Funciones relacionadas: itoa, ltoa.
F.10.
Funciones relacionadas: atoi, atof, atol, ltoa, strtoul.
strtoul
ultoa
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 especficas que realizan:
#include <stdlib.h>
unsigned long strtoul(const char *cad, char **p, int base);
Convierte una cadena de caracteres a un entero largo sin signo en la

base dada. La cadena debe tener el formato:
[espacio en blanco][0][x|X][ddd]
dgitos decimales
octal
blanco o tabulaciones hexadecimal
Si la base b es cero, strtoul utiliza el primer carcter de la cadena para
determinar la base del valor.
La cadena cad puede contener hasta 33 caracteres, excluyendo el carcter de terminacin nulo (\0,). Si se produce un error de desbordamiento,
la variable errno se pone al valor de ERANTE.
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 eleccin adecuada de las funciones disponibles permite procesar datos en tamaos y formatos diferentes, desde caracteres independientes a estructuras de datos complejos. La E/S por secuencia, o flujo,
tambin proporciona acciones de taponamiento (buffering) que mejoran significativamente el rendimiento. Para utilizar los flujos, generalmente se
debe incluir el archivo stdio.h.
clearerr
void
#include <stdio.h>
clearerr(FILE *f);
Reinicializa el indicador de error de un flujo f.

i = strtoul(cad_ent, &ptrfin, base);
clearerr(fichen);
Funciones relacionadas: atol, ultoa, strtol.
Funciones relacionadas: eof, feof, ferror, perror.
fclose, fcloseall
#include <stdio.h>
int fclose(FILE *f);

int fcloseall(void);
#include <stdio.h>
fflush(FILE *f);
int
Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall)

excepto stdin, stdout y stderr. Se devuelve el nmero de flujos cerrados
y EOF si se produce un error.
Limpia (vaca) un flujo. Los buffers se limpian automticamente cuando estn llenos, cuando se cierra el flujo, o cuando un programa termina normalmente sin cerrar el flujo.
fflush(fp);
fcloseall();
Funciones relacionadas: close, fdopen, fopen.

fdopen
fflush
639
#include <stdio.h>
Funciones relacionadas: fclose, flshall, fopen.

fgetc
#include <stdio.h>
int fgetc(FILE * f);
FILE *fdopen(int handle, char *modo);
Abre un flujo utilizando un handle (entero devuelto por las rutinas de

E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una
estructura de datos FILE con el archivo especificado por handle.
Lee un carcter de la posicin actual del archivo y, a continuacin,

incrementa esta posicin.
c = fgetc(fp)
p_datos = fdopen(handle, rb);
Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc,

Funciones relacionadas: fclose, fopen, fropen, open.
putchar.
feof
fgetchar
int
#include <stdio.h>
feof(FILE *flujo);
#int fgetchar(void);
Comprueba el final de archivo de un flujo.
Lee un carcter del archivo stdin, normalmente el teclado.
feof(fichen);
c = fgetchar();
Funciones relacionadas: clearerr, fclose, rewind.

ferror
int
#include <stdio.h>
#include <stdio.h>
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.

fgetpos
#include <stdio.h>
ferror(FILE *f);
int fgetpos(FILE *flujo, fpos_t *p);
Verifica si se ha producido un error en un flujo f.

ferror(fichen);
Obtiene y graba la posicin actual del archivo. fos_t es un tipo definido en stdio.h.
Funciones relacionadas: clarerr, eof, feof, fopen, perror.
fgetpos(fp, &pos_archivo);
640
fgets
#include <stdio.h>
char *fgets(char *cad, int n, FILE
*f);
if ((corriente2 = fopen(datos, W+)) == NULL

printf(el archivo..no se ha abierto \n);
Funciones relacionadas: fclose, fcloseall, fdopen, ferror,
Lee una cadena de un flujo (hasta que se encuentra \n, o el nmero

mximo de caracteres especificados).
fileno, freopen, open, setmode.
fgets(caddemo,80, fp);
flushall
Funciones relacionadas: fputs, gets, puts.
int flushall(void);
#include stdio.h>
Vaca (limpia) todos los buffers asociados con los archivos abiertos.
fileno
#include <stdio.h>
numvaciados = flushall();
int fileno(FILE *f);
Funciones relacionadas: fclose, fflush.
Obtiene el mando o manejador (handle) del archivo asociado con un

flujo.
fprintf
#include <stdio.h>
fileno(stdin);
int fprintf(FILE *f, const char *formato[arg,...]);
Funciones relacionadas: fdopen, fopen.

Imprime datos con formato en un flujo.
fopen
#include <stdio.h>
FILE *fopen(const char *f, const char *modo);
Abre un archivo f. La cadena de caracteres modo especifica el tipo de

acceso.
Modo
Accin
r
w
a
r+
w+
a+
rb
wb
ab
rb
wb
ab
Abre para lectura.

Abre un archivo vaco para escritura.
Abre para escritura al final del archivo (aadir).
Abre para lectura/escritura.
Abre un archivo vaco para lectura/escritura.
Abre para lectura y aadir.
Abre un archivo binario para lectura.
Crea un archivo binario para escritura.
Abre un archivo binario para aadir.
Abre un archivo binario para lectura/escritura.
Crea un archivo binario para la lectura/escritura.
Abre o crea un archivo binario para lectura/escritura.
fprintf(f1,El resultado es %f\n,result);
Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
fputc
#include <stdio.h>
int fputc(int c, FILE *f);
Escribe un carcter 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 <stdio.h>
Escribe el carcter c en stdout.
641
Lee datos con formato de un flujo.
fputchar(q);
fscanf(flujo, %s%f, cad, &f);
Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.
Funciones relacionadas: csanf, fprintf, scanf, sscanf.
fputs
fseek
#include <stdio.h>
#include <stdio.h>
int fputs(const char *cad, FILE *f);
int fseek(FILE *f, long desp, int org);
Escribe una letra cad en un flujo f. Devuelve el ltimo carcter impreso, si hay error devuelve EOF.
Mueve el puntero del archivo asociado con f a una nueva posicin que
est desplazada desp bytes de org.
fputs(esto es una prueba, f1);
Origen
Significado
Funciones relacionadas fgets, gets, puts.
SEEK_SET
SEEK_CUR
SEK_END
Principio de archivo.
Posicin actual puntero archivo.
Final de archivo.
fread
#include <stdio.h>
fseek(f1,OL,SEEK_SET);
// ir al principio
size_t fread(void *p, size_t t, size_t n, FILE *f);
Funciones relacionadas: ftell, rewind, fopen.

Lee n registros de t bytes en la memoria apuntada por p desde el flujo f.
fread(buf, strlen(msg)+1, 1, flujo);
fsetpos
Funciones relacionadas: fwrite, read.
int fsetpos(FILE *f, const fpos_t *p);
freopen
#include <stdio.h>
FILE *freopen(const char *f, const char *m, FILE *flujo);
Cierra el archivo asociado con flujo y reasigna flujo al archivo especificado por f. Los modos (m) utilizados son los mismos de fopen.
Establece la posicin del puntero del archivo al lugar especificado por

el objeto apuntado por p.
fsetpos(fp, &posarch);
Funciones relacionadas: getpos.

ftell
freopen(salida.txt, w, stdout);
#include <stdio.h>
#include <stdio.h>
long int ftell(FILE *f);
Funciones relacionadas: fclose, fopen.
Obtiene la posicin actual (puntero) del archivo asociado con el flujo f.

fscanf
#include <stdio.h>
int fscanf(FILE *f, const char *formato [, direccin,...]);
ftell(fichen);
Funciones relacionadas: fgetpos, fssek, tell.
642
fwrite
#include <stdio.h>
Devuelve el siguiente carcter de stdin. Si se alcanza el final de archivo, se devuelve EOF.
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 nmero de caracteres realmente escritos
que, si la funcin tiene xito, es igual al nmero indicado.
num = fwrite(lista, sizeof(char),25,flujo);
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
getc
#include <stdio.h>
int getc(FILE *f);
int getche(void);
Lee un carcter del teclado haciendo eco del carcter en la pantalla.
Devuelve el siguiente carcter de un flujo de entrada dado e incrementa la posicin actual del puntero del archivo. Si se alcanza el final de archivo, se devuelve EOF.
whilec(c = getc(fx)!= EOF) {
printf(%c, c);
}
resp= getche();
Funciones relacionadas: cgets, getch, getchar, ungetch.
gets
Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc,

putchar, fopen.
getch
#include <stdio.h>
#include <stdio.h>
#include <stdio.h>
char *gets(char *cad);
Lee una lnea desde el archivo de entrada estndar stdin, por omisin
es el teclado y lo guarda en cad.
gets(nombre);
int getch(void)
Lee un carcter del teclado sin hacer eco en la pantalla.

{
car = getch();
char = toupper(car);
} while(car != S);
Funciones relacionadas: fgets, fputs, puts.
do
getw
#include <sdio.h>
int getw(FILE *f);
Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.

Lee un entero (o una palabra de dos bytes) de un flujo f.
getchar
int getchar(void);
#include <stdio.h>
suma = getw(fx) + suma;
Funciones relacionadas: fread, putw.
printf
#include <stdio.h>
int printf(const char *formato[,argumento,...]);
Escribe cadenas de caracteres y valores de variables, con formato, en el

archivo de salida estndar stdout (por omisin, la pantalla).
Formato
%c
Carcter.
Entero decimal.
Real (double o float), notacin cientfica.
Coma flotante.
Cadena de caracteres.
Hexadecimal sin signo.
%e
%f
%s
%x
#include <stdio.h>
int puts(const char *cad);
Escribe una cadena en el archivo de salida estndar stdout.

puts(Desea continuar(s/n?);
Funciones relacionadas: fgets, fputs, gets.
Cdigo
%d
puts
643
putw
#include <stdio.h>
int putw(int i, FILE *f);
Escribe un entero en un flujo f.

putw(100, fx);
printf(producto %d y %d es %d\n,x,y, x*y);
Funciones relacionadas: getw, printf.
Funciones relacionadas: fprintf, scanf, sprintf, viprintf,

vprintf, vsprintf.
rewind
#include <stdio.h>
void rewind(FILE *f);

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

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

int putchar(int c);
Funciones relacionadas: fseek.
Escribe un carcter en un flujo (putc) o en stdout (putchar).

scanf
#include <stdio.h>
putc(*, demo);
int scanf(const char *formato[,direccin,...]);
Funciones relacionadas: fputc, fputchar, getc, getchar.
putch
int putch(int c);
Escribe un carcter en la pantalla.

putch(B);
Lee datos con formato del flujo de entrada estndar.

Cdigo
Formato
%c
%d
%x
%i
%f
%o
Carcter.
Entero decimal.
Hexadecimal.
Entero decimal.
Nmero real.
Octal.
Puntero.
Cadena.
#include <stdio.h>
%p
Funciones relacionadas: putc, putchar.
%s
644
scanf(%d %f %c %s, &i, &fp, &c, s);
Funciones relacionadas: fscanf, printf, sscanf, vfprintf,

vprintf, vsprintf
Esta funcin es idntica a scanf, excepto que los datos son ledos del
array apuntado por b, en vez de stdin.
sscanf(buffer, %,s%s,uno,dos,tres);
Funciones relacionadas: cscanf, fscanf, scanf, vscanf.

setbuf
#include <stdio.h>
void setbuf(FILE *f, char *buffer);
tmpfile
Asigna un buffer a un flujo.
#include <stdio.h>
FILE *tmpfile(void);
Crea un archivo temporal y devuelve un puntero a ese flujo.
setbuf(fx, buffer);
Funciones relacionadas: setvbuf.
if((aux = tmpfile()) == NULL)...
Funciones relacionadas: tmpnam.

setvbuf
#include <stdio.h>
int setvbuf(FILE *f, char *b, int t, size_t l);
tmpnam
Asigna el buffer b de tamao l y el tipo t con el flujo (archivo) f. Los

valores correctos de t son: _IOBF, _IONBF e _IOLBF.
char *tmpnam(char *s);
#include <stdio.h>
Genera un nico nombre de archivo y lo guarda en el array apuntado por s.

setvbuf(demo, buffer, _IOFBF, 120);
tmpnam(prueba);
Funciones relacionadas: setbuf.

Funciones relacionadas: tmpfile.
sprintf
#include <stdio.h>
ungetc
#include <stdio.h>
int sprintf(char *b, const char *f[,arg,...]);

int ungetc(int c, FILE *f);
Escribe datos con formato en una cadena. Se diferencia de printf en

que la salida generada se sita en el array apuntado por b.
Sita un carcter, excepto la constante EOF, en el buffer asociado con un

archivo abierto para entrada con buffer.
sprintf(cad, &s %d %c, uno,5,7);

ungetc(car, stdin);
Funciones relacionadas: sprintf, printf, vprintf, vfprintf,

Funciones relacionadas: getc.
vsprintf.
sscanf
#include <stdio.h>
int sscanf(const char *b, const char *f[,direccin,...]);
ungetch
int ungetch(int ch);
#include <stdio.h>
Empuja un carcter en la memoria intermedia del teclado.

char ch;
ch = getch();
ungetch(ch);
vfprintf,
vprintf,
vsprintf
vsscanf
645
#include <stdio.h>
#include <stdarg.h>
int vsscanf(const char *b, const char *f, lista_va

lista_arg);
#include <stdio.h>
#include <stdarg.h>
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);
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,
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
inclusin stdio.h.
va_end, va_strat.
vfscanf
#include <stdio.h>
#include <stdarg.h>
_close, close
#include <io.h>
int _close(int h);

int close(int h);
int vfscanf(FILE *F, const char *f, lista_va lista_arg);
Lee entrada con formato de un flujo, tal como scanf, excepto que vfs-
Cierra el archivo especificado en h. Estas funciones se utilizan con
canf acepta un puntero a la lista de argumentos.
_open y open.
vfscanf(demo, formato, arg);
close(f1);
Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf.
Funciones relacionadas: fclose, fopen, open.
vscanf
_creat
creat
#include <stdio.h>
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.
#include <io.h>
#include <sys\stat.h>
#include <dos.h>
int creat(const char *cam, int modo);

int _creat(const char *cam, int atributo);
vscanf(formato, argumento);
Funciones relacionadas: fscanf, scanf, sscanf, fsca.
Crea un nuevo archivo o abre y trunca un archivo existente. _creat()

acta igual que creat(), excepto que utiliza un byte de atributo del DOS.
646
Modo
Significado
S_IWRITE
S_IREAD
S_IREAD|S_IWRITE
Permiso de escritura.
Permiso de lectura.
Permiso de lectura y escritura.
eof
fh= creat(datos,S_IREAD|S_IWRITE);
Funciones relacionadas: chmod, close, open umask.
#include <io.h>
int eof(int d);
Comprueba si el archivo especificado en el descriptor d es el final de

archivo (se devuelve 1 si se alcanza el final del archivo. 0 si no se alcanza
el final del archivo, 1 indica un error y errno toma valor EBADF: nmero
de archivo incorrecto).
while(!eof(fx))
creatnew
#include <io.h>
#include <dos.h>
int creatnew(const char *camino, int atributo);
Crea un archivo nuevo con los atributos especificados.

h = creatnew(F.FIL,0);
Funciones relacionadas: feof, ferror, perror.

lseek
#include <io.h>
#include <stdio.h>
long lseek(int d, long desp, int origen);
La funcin lseek mueve el puntero asociado con el descriptor d a una

nueva posicin que est emplazada desp bytes de origen.
Funciones relacionadas: _creat, fopen, open.
pos = lseek(fh, OL, SEEK_CUR);

creattemp
int
#include <io.h>
#include <dos.h>
creattemp(char *camino, int atributo);
Funciones relacionadas: fseek, tell.

open
#include <fcntl.h>
#include <io.h>
Crea un nico archivo temporal con byte de atributo en el directorio

escrito por camino.
int open(const char *f, int a[, unisgned m]);

if((h = creattemp(nombre,9))== -1
Abre el archivo especificado en f para lectura o escritura. El argumento a indica el tipo de operacin permitida y m el tipo de permiso.
Funciones relacionadas: tmpfile.

dup, dup2
#include <io.h>
int dup(int h);

int dup2(int h1, int h2);
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace

de archivo (dup2).
viejostdout = dup(STDOUT);
dup2(fptr, STDOUT);
Funciones relacionadas: close, creat, open.
Indicador
Lectura/escritura
O_RDONLY
O_WRONLY
O_RDWR
O_NDELAY
O_APPEND
O_TRUNC
O_EXCL
O_BINARY
O_TEXT
Significado
Abrir para lectura.
Abrir para escritura.
Abrir para lectura y escritura.
Pone el puntero del archivo al final del archivo.
Se crea el archivo y se fijan atributos del archivo.
Trunca el archivo a 0.
Se utiliza con O_CREAT.
Abrir archivo en modo binario.
Abrir archivo en modo texto.
open(OPEN.OUT, 0_WRONLY|O_CREAT, S_IREAD|IWRITE);

if((h = open(open.tst, O_CREAT))==1)...
647
Devuelve la posicin actual del puntero del archivo especificado por d.

posi = tell(desf);
Funciones relacionadas: access, chmod, close, creat, fopen.

Funciones relacionadas: ftell, lseek.
sopen
#include <fcntl.h>
#include <io.h>
#include <share.h>
#include <sys/stat.h>
write
#include <io.h>
int write(int d, void *buffer, unsigned lon);

int sopen(char *f, int a, int s[, int m]);
Abre un archivo f con acceso a en modo compartido en un entorno de

red y con el tipo s de comparticin permitido en el archivo y modo m.
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
Significado
Funciones relacionadas: creat, open, read, sopen.
O_RDONLY
O_WRONLY
O_RDWR
S_IWRITE
S_IREAD
S_IWRITE|S_IREAD
Abrir para lectura.

Abrir para escritura.
Abrir para lectura y escritura.
Acceso de escritura.
Acceso de lectura.
Acceso de lectura y escritura.
Funciones de consola y puertos de E/S
Las funciones de E/S sirven para interactuar con el teclado y la pantalla.

Estas funciones se declaran en el archivo de cabecera conio.h.
cgets
#include <conio.h>
df = sopen(C:||autoexec.bat, O_RDONLY, SH_DENYRW, S_IREAD);

char *cgets(char *cadena);
Funciones relacionadas: close, fopen.

read
Lee una cadena de caracteres directamente de la consola, y almacena la

cadena y su longitud en la posicin apuntada por cadena.
#include <io.h>
entrada = cgets(cadena);
int read (int d, void * buffer, unsigned lon);
Funciones relacionadas: cputs, getch, getche.
Lee lon bytes del archivo asociado con d en el buffer apuntado por
buffer.
cprintf
read(fx, buffer, 100);
#include <conio.h>
int cprintf(const char *formato[,arg,...]);

tell
#include <io.h>
Escribe salida con formato directamente en la consola. Observe que

long tell(int d);
cprintf no traduce el carcter (\n) a una combinacin (CR-LF), en su lugar,
648
\n se interpreta como avance de lnea (LF) y \r se debe utilizar para indicar

un retorno de carro (CR).
getpass
#include <conio.h>
char *getpass(const char *indicador);

cprintf(Cubo de %2d es %rd\r\n,i, i * i * i);
Lee una palabra de paso por consola, que no se visualiza en pantalla

(menos de ocho caracteres de longitud).
Funciones relacionadas: printf.
palabrapaso = getpass(Introduzca clave);

cputs
#include <conio.h>
Funciones relacionadas: getch
int cputs(const char *cad);
Escribe una cadena en la pantalla. No se enva ningn carcter de nueva

lnea despus de la cadena.
Funciones relacionadas cprintf.
int
#include <dos.h>
int inport(int puerto);

unsigned char inportb(int puerto);
cuts(Est usted seguro(s/n)?);
cscanf
inport, inportb
#include <conio.h>
cscanf(char *formato [,direccin,...]);
Lee una palabra de 16 bits (inport) o un byte (inportb) de un puerto

de E/S especificado por puerto.
La funcin 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);
Lee caracteres con formato directamente desde la consola en la posicin

dada por direccin.
Funciones relacionadas: outport, poutportb.
cscanf(%d%d%d, &dia, &mes, &hora);
kbhit
Funciones relacionadas: fscanf, scanf, sscanf.
int kbhit(void);
#include <conio.h>
Comprueba si se ha pulsado recientemente una tecla.

get, getche
#include <conio.h>
int getch(void);
int getche(void);
// visualizar hasta que pulsa una tecla

while(!kbhit())
cputs(Pulse una tecla);
Funciones relacionadas: getch, getche.

Lee un carcter de la consola sin eco (getch) o con eco (getche).
printf(Pulse cualquier tecla para salir);
getch();
Funciones relacionadas: cgets, getchar, ungetch.
outport, outportb
#include <conio.h>
void outport(int puerto, int palabra);

void outportb(int puerto, unsigned char byte);
Escribe una palabra de 16 bits (outport) un byte (outportb) en un

puerto de E/S.
outport(23,0);
outport(A, 0)
Verifica si existe un archivo y, en caso afirmativo, los permisos de acceso al archivo.
// 23 fuera del puerto

// A fuera de puerto
Funciones relacionadas: inp, inport, inportb, inpw.

putch
649
#include <conio.h>
Modo
Significado
00
01
02
04
06
Se verifica existencia del archivo.

Ejecutar.
Verifica permiso de escritura.
Verifica permiso de lectura.
Verifica permiso de lectura y escritura.
int putch(int c);

return(access(nombre, 4)==-1)
Escribe un carcter en la consola (sin accin del buffer).

Funciones relacionadas: chmod, fstat, stat.
putch(car); putch(\n); putch(x);
Funciones relacionadas: getch, getche.

ungetch
chmod
#include <conio.h>
int chmod(const char *camino, int pmodo);
int ungetch(int c);
Cambia los permisos de lectura/escritura de un archivo.
Sita un carcter en el buffer del teclado de modo que es el siguiente

carcter ledo en la consola.
r = chmod(prueba.tst, S_IREAD);
Funciones relacionadas: access, fstat, stat.
if(c =!EOF) ungetch(c);

ungetch(car);
Funciones relacionadas: getch, getche, ungetc.
F.11.
#include <stdio.h>
FUNCIONES DE GESTIN DE ARCHIVOS
El sistema de archivos es un componente clave del/de la PC. Todas las aplicaciones y datos residen en archivos. Las funciones de gestin de archivos
permiten establecer y verificar permisos de acceso a archivos. La mayora
de las funciones estn en el archivo de cabecera io.h, y las restantes en
sys|stat.h, dir.h y stdio.h.
pmodo
Permiso de acceso
S_IWRITE
S_IREAD
S_IREAD|S_IWRITE
Escritura.
Lectura.
Lectura/Escritura.
chsize
#include <io.h>
int chsize(int manejador, long longitud);
Cambia el tamao del archivo.

access
int access(const char *nomarch, int modo);
#include <io.h>
chsize(fh, 5);
Funciones relacionadas: access, chmod, fstat, stat.
650
filelength
#include <io.h>
Devuelve informacin sobre el archivo especificado en la estructura de

tipo stat apuntada por buffer. La estructura stat es:
long filelenght(int manejador);
Obtiene la longitud de un archivo en bytes.

filelength(fh);
Funciones relacionadas: fileno, filestat, stat.
fnmerge
#include <dir.h>
void fnmerge(char *camino, const char *unidad,

const char *dir, const char *nombref, const char *ext);
Crea un nombre de camino completo (letra, unidad, camino directorio,

nombre de archivo y extensin del archivo). En Microsoft, la funcin equivalente es _makepath.
fnmerge(camino,C:,\\aux,resultado,.dat);
// nombre de caminoC:\aux\resultado.dat
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;
};
//
//
//
//
//
//
//
//
//
//
//
unidad o dispositivo
nmero inodo (UNIX)
modo archivo
nmero enlaces (DOS,1)
id de usuario (UNIX)
id de grupo (slo UNIX)
dispositivo UNIX
tamao archivo en bytes
hora ltimo acceso
hora ltima (UNIX)
hora creacin
fstat(fich, &info);
Funciones relacionadas: access, chmod, stat.
isatty
#include <io.h>
int isatty(int h);
Funciones relacionadas: fnsplit.
Determina si es un dispositivo orientado a carcter (terminal, consola,

impresora o puerto serie).
fnsplit
#include <dir.h>
int fnsplit(const char *camino, char *unidad,

char *dir, char *fnombre, char *ext);
if(isatty(fileno(stdout)))
puts(es consola);
Separa un nombre de camino completo en sus componentes: letra, unidad, camino, nombre y extensin del archivo.
lock
f = fnsplit(c, unidad, dir, arch, ext);
int lock(int h, long d, long n);
Funciones relacionadas: fnmerge.
Bloquea un nmero de bytes n del archivo h (manejador) con desplazamiento se utiliza para comparticin de archivos (orden SHARE de MSDOS). En Visual C++, la funcin equivalente es locking.
fstat
int fstat(int h, struct stat *buffer);
res lock(h, 0L,256);
#include <io.h>
bloque de 256 bytes
Funciones relacionadas: sopen, unlock.
mktemp
#include <dir.h>
char * mktemp(char *plantilla);
Crea un nico nombre de archivo modificando una plantilla dada como

argumento, plantilla toma la forma basexxxxxx, donde base es el nombre que se proporciona y x los caracteres a modificar.
char modelo = tcbxxxxxx;
mktemp(modelo);
651
modo 0_BINARY(binario) 0_TEXT(texto)

setmode(fileno(stdin), 0_BINARY);
// modo binario
Funciones relacionadas: fopen, open.

stat
int stat(char *f, struct stat *buffer);
Obtiene informacin sobre el estado de un archivo existente f.
Funciones relacionadas: tmpfile, tmpnam.
resultado = stat(stat.c,&buf);
remove
#include <stdio.h>
Funciones relacionadas: access, chmod, fstat.
int remove(const char *camino);

umask
#include <io.h>
Borra el archivo especificado en camino.

unsigned umask(unsigned Pmodo);
remove(C:\\ux\\demo);
// borra demo
Funciones relacionadas: unlink.
rename
#include <stdio.h>
int rename(const char *vn, const char *nn);
Establece la mscara de permisos de lectura/escritura usados por open

y create.
Pmodo S_IREAD (slo lectura)
S_IWRITE (slo escritura)
S_IREAD|S_IWRITE (lectura/escritura)
viejamascara = umask(S_IWRITE);
Funciones relacionadas: chmod, creat, mkdir, open, sopen.
Renombre el archivo vn a nn.

unlink
int resultado;
resultado = rename(viejo, nuevo);
Funciones relacionadas: creat, fopen, open.
#include <dos.h>
#include <io.h>
#include <stdio.h>
int unlink(const char *camino);
Borra un archivo especificado en camino, que no sea de slo lectura.

setmode
#include <io.h>
#include <fcntl.h>
int setmode(int h, int modo);
Permite cambiar el modo del archivo abierto entre texto y binario.
result = unlink (demo.jnk);

if (result==0)
printf (unlink tuvo xito);
Funciones relacionadas: remove.
652
unlock
#include <conio.h>
Las funciones complejas son propias de Borland C++ y no son exportables.
int unlock(int h, long o, long l);
Desbloquea una seccin del archivo h que ha sido bloqueada con lock.
unlock(m,OL,256);
// desbloquea 256 bytes
Funciones relacionadas: lock, sopen.
F.12.
FUNCIONES MATEMTICAS
El C original de K&R fue diseado, inicialmente, como un lenguaje de programacin de sistemas, su uso ha sido muy escaso en el campo del clculo
cientfico. Sin embargo, desde la normalizacin de ANSI C y su extensa
biblioteca matemtica, C se ha convertido en un fuerte rival del lenguaje
cientfico por excelencia, FORTRAN. C soporta operaciones de coma flotante e incluye tambin un rico conjunto de funciones matemticas. Borland
C++ ha ampliado las propiedades de ANSI C estndar.
Los archivos de cabecera que contienen funciones matemticas 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,
Clase bcd
La clase bcd permite manipular nmeros almacenados en notacin decimal

codificado a binario (BCD) y proporciona hasta 17 dgitos decimales de
precisin, y un rango de 1 10-125 a 1 10125.
abs versin real
#include <math.h>
#include <stdlib.h>
#include <complex.h>
versin compleja
int abs (int x);
double abs(complex x);
Proporciona el valor absoluto de un entero o de un nmero complejo:

abs(-50) devuelve 50. Para utilizar nmeros complejos se requiere el
archivo de cabecera complex.h.
x = abs(-7)
// x es 7
_fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min,

poly, pow10, random, randomize, _rotl, _rotr, _status87.
Funciones relacionadas: cabs, fabs, labs.
Adems de estas funciones, Borland C++ soporta dos clases especficas

importantes: complex y bcd, se encuentran en los archivos complex.h y
bcd.h, respectivamente.
acos
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 nmero complejo z y que se define as:
struct complex
{
double x;
double y;
}
#include <math.h>
double acos(double x);

complex acos(complex x);
La funcin 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);
// parte real del nmero complejo

// parte imaginaria del complejo
Funciones relacionadas: cos, matherr.
Se puede declarar e inicializar un nmero complejo (x + yi) de esta

forma:
arg
struct complex z = {1.5,1.5}
double
// z = 1.5 + i1.5;
// el ngulo devuelto es //3
arg(complex x);
653
La funcin arg() devuelve el ngulo, en radianes, de un nmero en el

plano complejo.
Calcula el arco tangente de y/x. El resultado es un ngulo de valor

comprendido entre / y / radianes.
complex z;
double angulo;
z = complex(1.5, 4.5);
angulo = arg(z);
angulo = atan2(y, x);
Funciones relacionadas: complex, norm, polar.
cabs
Funciones relacionadas: atan, matherr, tan.

#include <math.h>
double babs(struct complex z);

asin versin real
#include <math.h>
versin compleja
Calcula el valor absoluto de un nmero complejo almacenado en una

estructura de tipo complex.
double asin(double x);
Calcula el arco seno del argumento x; el valor de x debe estar comprendido entre 1 y 1. La funcin asin() devuelve un valor entre //2 y /,
el valor de x debe ser en radianes.
struct complex z;
double complejo;
z.y = 3.5
z.y = 2.4
complejo = cabs(z);
printf(valor absoluto %lf\n, complejo);
Z = asin(0.7543);
Funciones relacionadas: fabs, hypot, matherr, sqrt.

Funciones relacionadas: matherr, sin.
ceil
atan versin real
#include <math.h>
versin compleja
#include <math.h>
double ceil (double x);
Calcula (redondea) el nmero entero mayor que o igual a x.
double atan(double x);
Calcula el arco tangente de x. El rango x es 1 a 1. La funcin atan()

devuelve un valor en el rango de //2 a //2.
redondeo = ceil(5.1)
// redondeo es 6
Funciones relacionadas: floor.
complex atan(complex x);
angulo = atan(1.0);
// ngulo es Pi/4 (45 grados)
_clear87
#include <float.h>
unsigned int _clear87(void);
Funciones relacionadas: atan2.
Borra (limpia) la palabra del estado de coma flotante.

atan2
double atan2 (double y, double x);
#include <math.h>
estado = _clear87();
Funciones relacionadas: _control87, _status87.
654
_control87
#include <float.h>
unsigned int _control87(unsigned int nuevo, unsigned int

mascara);
Obtiene y establece la palabra de control de coma flotante. Cuando se

utiliza un coprocesador matemtico 8087, _control87 establece su palabra
de control.
La funcin div() calcula el cociente entero y el resto de x por y. La

funcin 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
estado = control87(PC24,MCW_IC);
// precisin 24 bits
Funciones relacionadas: _clear87, _status87.

exp
cos
#include <amth.h>
#include <math.h>
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.
Calcula el exponencial de x:ex; donde e es la base del logaritmo natural (e = 2.7182818).
coseno_x = cos(1.6543);
x = 100.00;
y = exp(x);
printf(El exponencial de x = %f.\n,y);
Funciones relacionadas: acos, sin.

cosh
#include <math.h>
Funciones relacionadas: log, pow.
double cosh(double x);

complex cosh(complex x);
fabs, fabsl
Calcula el coseno hiperblico de la variable x. Si el argumento pasado

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

long double fabs(long double x);
x = 1.00
printf(x = %f.\n\n,x);
y = cosh(x);
printf(coseno hiperblico x = %f.\n\n, y);
div_t div(int x, int y);
Calcula el valor absoluto de un nmero en coma flotante x.

y = fabs(-7.25);
// y vale 7.25
Funciones relacionadas: cabs.
Funciones relacionadas: sinh.

div
#include <math.h>
#include <stdlib.h>
floor
double floor(double x);
#include <math.h>
Redondea por defecto el valor de x.

x = floor(6.25);
double x, y;
int n;
x = 17.5;
y = frexp(x, &n);
printf(frexp(%f, &n) = %f, n = %d\n,x,y,n);
// x vale 6
Funciones relacionadas: ceil.
Funciones relacionadas: exp, ldexp, modf.
fmod
#include <math.h>
double fmod(double x, double y);
hypot
#include <math.h>
double hypot(double x, double y);
Calcula el resto de la divisin real x por y.

resto = (fmod(5.0, 2.0);
655
Calcula la hipotenusa de un tringulo rectngulo cuyos lados son x e y.

Una llamada a hypot equivale a lo siguiente:
// resto igual a 1.0

sqrt(x * x, y * y);
Funciones relacionadas: floor.

double x = 3.0; y = 4.0;
printf(%lf, hypot(x, y));
_fpreset
#include <float.h>
imag
void _fpreset(void);
Reinicializa el paquete matemtico de coma flotante. Debe utilizarse

despus de las llamadas a las funciones system(), exec(), span() sobre
mquinas con coprocesadores matemticos.
_fpreset();
// inicializa paquete de coma flotante *t
Funciones relacionadas: _control87, signal.
double imag(complex x);
Devuelve la parte imaginaria de un nmero complejo x. Esta funcin no

es transportable.
double x = 3.4, y = 4.5;
complex = complex(x, y);
cout << parte imaginaria: << imag(z) << \;
Funciones imaginarias: complex, conj, real.

frexp(), frexpl()
#include <math.h>
double frexp(double x, int *exp);

long double frexpl(long double x, int *exp);
La funcin frexp descompone el valor x en una mantisa (m) y en un

exponente n, tal que el valor absoluto de m es mayor o igual a 0,5 y menor
que 1,0 y x + m*2n. La mantisa se obtiene por la funcin, y el exponente se
almacena en la variable apuntada por exp.frexpl descompone un valor
long double.
labs
long int labs(long int n);
Calcula el valor absoluto de un entero largo (n).

long lx = 51654L, ly;
ly = labs(lx);
Funciones relacionadas: abs, cabs, fabs.
#include <math.h>
656
ldesp, ldespl
#include <math.h>
double ldesp(double x, int exp);

long double ldexpl(long double x, int exp);
stderr, la variable global errno toma el valor EDOM y devuelve el valor

HUGE_VAL. Si x es 0, la funcin 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);
Calcula y devuelve el valor real de x*e .

exp
double x = 4.0,y;
int p = 5;
y = ldexp(x, p);
Funciones relacionadas: exp, matherr pow.
Funciones relacionadas: frexp, modf.

_lrotl
ldiv
#inxlude <stdlib.h>
ldiv_t ldiv(long int x, long int y);
Calcula el cociente y el resto de la divisin x/y. La funcin ldiv

devuelve una estructura de tipo ldiv_t que comprende el cociente y el
resto.
#include <stdlib.h>
unsigned long _lrotl(unsigned long x, int c);
Se utiliza _lrotl para rotar a la izquierda los bits de una variable entera larga sin signo x. La rotacin de un bit a la izquierda, una posicin, significa que el bit ms a la izquierda sale fuera y se inserta en su posicin el
siguiente bit de mayor peso, y los restantes bits se desplazan una posicin a
la izquierda.
typedef struct
unsigned long x = 0x0fac45491;

printf(x desplazado 4 veces es, _lrotl (x, 4);
Funciones relacionadas: _lrotr, _rotl, _rotv.
long quot;
long rem;
} ldiv_t;
_lrotr
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.
#include <stdlib.h>
unsigned long _lrotr(unsigned long x, int c);
Rota a la derecha los bits de x. Rotacin a derecha de un bit significa

salir fuera el bit de menor peso y los restantes se desplazan una posicin a
la derecha.
val_r = _lrotr(x, 4);
log, log10
#include <math.h>
Funciones relacionadas: _lrotl, _rotl, _rotr.
double log(double x);

double log10(double x);
matherr
_matherrl
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
int matherr(struct exception *e);

int _matherrl(struct _exception1 *e)
#include <math.h>
Esta funcin manipula errores matemticos. Las funciones matemticas

llaman a la rutina adecuada matherr cuando se detecta un error. Se puede
desarrollar su propia versin de matherr para personalizar su tratamiento
de errores. Para profundizar en esta funcin, consultar su referencia en
Library Reference de Borland C++ (pgs. 352-353).
Funciones relacionadas: Las funciones matemticas.
polar
657
complex polar(double modulo, double angulo);
Devuelve un nmero complejo con una magnitud (mdulo) y ngulo

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

*sin(ang);
(tipo) max(a, b);
Devuelve el mayor de dos valores. Ambos argumentos y la declaracin

de la funcin deben ser del mismo tipo.
poly
double dbl1, dbl2, dblmax;

dblmax = max(dbl1, dbl2);
#include <math.h>
double poly(double x, int n, double c[]);
Funciones relacionadas: min.

min
Funciones relacionadas: Slo existe en C+.
#include <stdlib.h>
(tipo) min(a, b);
Se utiliza poly para evaluar un polinomio en x, de grado n y cuyos coeficientes son los correspondientes al array c. La expresin utilizada para
evaluar el polinomio es:
c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]
Devuelve el menor de dos valores. Ambos argumentos y la declaracin

de la funcin deben ser del mismo tipo.
int i1, i2, minent;
minent = min(i1, i2);
// polinomio: 3x**2 + 2x + 1//

double c[] = {-10.0,2,c);
Funciones relacionadas: pow.
Funciones relacionadas: max.

rand
modf, modfl
#include <math.h>
double modf(double x, double *partent);

long double modfl(long double x, long double *partent);
La funcin modf divide un nmero de coma flotante en dos partes, entera y decimal. La parte entera de x se almacena en la posicin a cuya direccin apunta partent, y la parte decimal es devuelta por la funcin.
#include <stdlib.h>
int rand(void);
Genera un nmero pseudoaleatorio en el rango de 0 a RAND_MAX; esta

constante simblica est definida en <stdlib.h> y su valor es 215-1. Para inicializar el generador de nmeros pseudoaleatorios se debe utilizar randomize.
Para obtener un nmero en el rango de 0 a (n-1) hay que utilizar random.
pardecimal = modf(36.95, &parte_entera(;

// parte entera 36, parte decimal .95
// visualizar 10 nmeros aleatorios //

for(i = 0; 1 < 10; i++)
printf(%6d\, rand());
Funciones relacionadas: frexp,ldexp.
Funciones relacionadas: random, randomize, srand.
658
random
modelo_nuevo = _rotl(0x1234,8);
// resultado es 3412h
int random(int x);
Genera un nmero pseudoaleatorio en el rango de 0 a x-1.

// obtener un nmero aleatorio entre 0 y 20
numa1 = random(21);
Funciones relacionadas: rand, randomize.

randomize
Rota el valor de x,c bits a la izquierda.
#include <stdlib.h>
Funciones relacionadas: _lrotl, _rotr, _rotr.

_rotr
#include <stdlib.h>
unsigned _rotr(unsigned x, int c);

#include <stdlib.h>
#include <time.h>
Se utiliza _rotr para rotar a la derecha el valor de x,c bits.

_rotr(val, 4);
void randomize(void);
Funciones relacionadas: _lrotl, _lrotr, _rotl.
Inicializa (genera una semilla) el generador de nmeros pseudoaleatorios con una semilla aleatoria que es funcin de la hora actual. Esta funcin
impide que se repitan las mismas secuencias de nmeros aleatorios en diferentes ejecuciones.
sin
randomize();
double sin(double x);

complex sin(complex x);
Funciones relacionadas: rand, random, srand.

real
#include <bcdh.h>
double real(complex x);

double real(bcd x);
#include <math.h>
La funcin sin() proporciona el seno de x (se supone en radianes).

double x, y;
x = 0.52;
printf(x = %f radianes\n, x);
y = sin(x)
printf(el seno de x = %f\n, y);
Funciones relacionadas: asin, cos, sinh.
Devuelve la parte real de un nmero complejo x o convierte un nmero

BCD a float, double o long double.
complex z = complex(x, y)
cout << parte real: << real(z) << \n;
Funciones relacionadas: Funcin exclusiva de C++.
sinh
#include <math.h>
double sinh(double x);

complex sinh(complex x);
Devuelve el seno hiperblico de x (x, se supone en radianes).

_rotl
unsigned _ rotl(unsigned x, int c);
#include <stdlib.h>
y = sinh(x);
Funciones relacionadas: sin, cosh.
sqrt
#include <math.h>
double sqrt(double x);

complex sqrt(complex x);
tanh
659
#include <math.h>
double tanh(double x);

complex tanh(complex x);
Calcula la raz cuadrada de un nmero x no negativo.

printf(%lf,sqrt(25.0);
// se visualiza 5
Calcula la tangente hiperblica de x.

a = tanh(x);
Funciones relacionadas: exp, log, pow.
Funciones relacionadas: cosh, tanh.

srand
#include <stdlib.h>
F.13.
void srand(unsigned x);

srand inicializa el generador de nmeros aleatorios con la semilla x. Si
x es 1, el generador se reinicializa; cualquier otro valor de x fija el genera-
dor a un punto inicial aleatorio.

srand(semilla);
Funciones relacionadas: rand, randomize.

_status87
#include <float.h>
FUNCIONES DE MANIPULACIN DE BLOQUES

DE MEMORIA (BUFFERS)
Las rutinas de manipulacin de buffers son una forma general de las rutinas
de manipulacin de cadenas que operan sobre stas en C. Son tiles para trabajar con reas de memoria sobre la base de carcter a carcter. 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
carcter nulo (\0). Por consiguiente, las rutinas de manipulacin de buffers siempre toman un argumento longitud o cuenta.
Las rutinas de manipulacin requieren que el archivo de cabecera
<mem.h> se incluya en su programa.
unsigned int _status87(void);
Obtiene el contenido de la palabra de estado de coma flotante.
memccpy
#include <mem.h>
#include <string.h>
estado = _status87();
void *memccpy(void *dest, const void *s, int c, size_t n);
Funciones relacionadas: _clear87, _control87.

Copia n bytes desde s a dest hasta que n bytes han sido copiados o c
se copia a dest.
tan
#include <math.h>
double tan(double x);

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

y = tan(x)
Funciones relacionadas: atan.
res = memccpy(buf_dest, bufen, c, 81);
Funciones relacionadas: memcpy, memmove, movedata, movmem.
memchr
#include <mem.h>
#include <string.h>
void *memchr(const void *buf, int c, size_t n);
660
Busca un carcter especfico c en un buffer (buf) examinando los n primeros caracteres.

result = memchr(direc, I, 40);
void
Funciones relacionadas: memcmp, memicmp.

memcmp
memmove
#include <string.h>
#include <mem.h>
*memmove(void *dest, const void *f, size_t n);
Mueve n bytes de un buffer (f) a otro (dest).

#include <mem.h>
int memcmp(const void *b1, const void *b2, size_t n);
Compara n bytes de un buffer (b1) con los de otro buffer (b2). Devuelve un valor:
Funciones relacionadas: memccpy, memcpy, movedata.

memset
#include <string.h>
void *memset(void *s, int c, size_t n);
Fija los n primeros bytes del array s al carcter c.
< 0 si b1 < b2
= 0 si b1 = b2
> 0 si b1 > b2
resultado = memset(buffer,1, 50);
resultado = memcmp(buf1, buf2, sizeof(buf1));
Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.
Funciones relacionadas: memicmp.

movedata
memcpy
#include
void *memcpy(void *dest, const void *fuente, size_t n);
Copia n bytes de fuente en dest. Devuelve un puntero a dest.

memcpy(dest, fuente, 80):
Funciones relacionadas: memccpy, memmove, movedata.

memicmp
#include <mem.h>
#include <string.h>
#include <mem.h>
#include <string.h>
int memicmp (const void *b1, const void *b2, size_t n);
Compara un nmero de bytes de un buffer (b1) con otro (b2) sin hacer
caso del tamao de las letras en los dos buffers.
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 nmero de bytes que hay que mover.
movedata(seg1, off, seg2, dest_off, 4096);
Funciones relacionadas: memcpy, memmove, movmem, segread.

movmem
#include <mem.h>
void movmem(void *fuente, void *destino, unsigned n);
Copia n bytes de fuente a destino.
if(memicmp(buf1, buf2, 15) == 0)

puts(Los buffers son iguales en los 15 primeros bytes \n);
movmem(&fuente[6], fuente, sizeof(fuente));
Funciones relacionadas: memcmp.
Funciones relacionadas: memmove.
setmem
#include <mem.h>
clrscr
661
#include <conio.h>
void setmem(void *dest, unsigned long, char c);
void (clrscr(void);
Fija un bloque de long bytes en el buffer dest al carcter c. setmem es

til para inicializar buffers.
Borra la ventana actual y pone el cursor en la esquina superior izquierda (1,1).
setmem(buffer, 60, t);
clrscr();
Funciones relacionadas: memset.
Funciones relacionadas: clreol, textbackground, window.
swab
#include <stdlib.h>
delline
#include <conio.h>
void swab(char *fuente, char *destino, int n);
void
Copia un nmero par de bytes de una posicin a otra, intercambiando al

mismo tiempo cada par de bytes adyacentes.
Borra la lnea completa que contiene el cursor y desplaza hacia arriba

las lneas que haya debajo.
swab(mnpq, resultado, 4);

// resultado es nmpq
delline();
delline(void);
Funciones relacionadas: clreol, clrscr.

Funciones relacionadas: Slo est disponible en sistemas UNIX.
gettext
F.14.
FUNCIONES DE PRESENTACIN DE TEXTO
#include <conio.h>
int gettext(int izda, int arriba, int derecha, int abajo,

void *textbuf);
Las funciones de presentacin 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, vdeo 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.
Copia el contenido de un rea rectangular de la pantalla al buffer cuya

direccin se da en el argumento textbuf. Todas las coordenadas son absolutas.
clreol
Funciones relacionadas: movetext, puttext.
void
#include <conio.h>
if(!gettext(1,1,30,20, pan_grabada))
puts(color);
clreol(void);
gettextinfo
#include <conio.h>
Borra la lnea actual desde la posicin del cursor al final de la lnea.

void gettextinfo(struct text_info *r);
clreol()
Funciones relacionadas: clrscr, delline, textbackground, window.
Devuelve informacin relativa a las coordenadas de la ventana actual,

posicin del cursor dentro de la ventana, atributo del texto, las dimensiones
662
de la pantalla y el modo de texto actual. La informacin se devuelve en una

estructura text_info.
Inserta una lnea en blanco en la ventana de texto actual en la posicin

del cursor, desplazando el resto de las lneas situadas debajo.
struct text_info {
unsigned char winleft;
insline();
unsigned char
unsigned char
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
unsigned
};
char
char
char
char
char
char
char
char
//
//
wintop;
//
winright;
//
//
winbottom;
//
attribute;
//
normattr;
//
currmode;
//
screenheight;//
screenwidth; //
curx;
//
cury;
//
coordenadas x, y esquina superior

izquierda
ventana actual
coordenadas x, y esquina inferior
derecha
ventana actual
atributo texto actual
atributo texto normal
modo texto actual
altura de la pantalla
anchura pantalla
coordenada x cursor
coordenada y cursor
gotoxy
Funciones relacionadas: clreol, delline, window.
lowvideo
#include <conio.h>
void lowvideo(void);
Activa los caracteres a baja intensidad.

lowvideo();
Funciones relacionadas: highvideo, normvideo, textcolor.

#include <conio.h>
movetext
#include <conio.h>
void gotoxy(int x, int y);
Mueve el cursor a una posicin especificada (columna x, fila y) dentro

de la ventana de texto actual.
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 rectngulo en la pantalla de las mismas dimensiones.
gotoxy(15, 4);
Funciones relacionadas: wherex, wherey, window.
if (!movetext(1, 1, 30, 20, 40, 40))

puts(victoria);
highvideo
Funciones relacionadas: gettext, puttext.
#include <conio.h>
void highvideo(void);
normvideo
Activa caracteres de alta intensidad.
#include <conio.h>
void normvideo(void);
highvideo();
Funciones relacionadas: lowvideo, normvideo, textcolor.
Reinicializa los atributos de texto al valor que tenan antes de que arranque el programa.
normvideo();
insline
#include <conio.h>
Funciones relacionadas: highvideo, lowvideo, textattr, textcovoid insline(void);
lor.
puttext
#include <conio.h>
int puttext(int izda, int arriba, int dcha, int abajo,

void *textbuf);
Copia el contenido de un buffer en una zona rectangular de la pantalla

en modo texto.
textbackground
663
#include <conio.h>
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 <conio.h>
void textcolor(int colorprimerplano);

_setcursortype
#include <conio.h>
void setcursortype(int estilo_cursor);
Cambia la forma del cursor en modo texto. El argumento tiene que ser
una de las constantes.
_NOCURSOR
_SOLIDCURSOR
_NORMALCURSOR
Desactiva el cursor.
Un carcter bloque slido es el cursor.
Un subrayado parpadeante es el cursor.
Establece el color del primer plano del texto visualizado por cprintf y
cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15
WHITE (blanco).
textcolor(15);t
Funciones relacionadas: textattr, textbackground.
setcursortype(_SOLIDCURSOR);
texmode
Funciones relacionadas: cprintf, cputs.
void textmode(int nuevomodo);
#include <conio.h>
Conmuta al modo texto especificado por el argumento nuevomodo.

textattr
#include <conio.h>
void textattr(int atrib);
Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia

del texto en la pantalla.
textattr(YELLOW + (RED << 4));
textattr(10110100);
-1
0
1
2
3
7
64
LASTMODE
BW40
C40
BW80
C80
MONO
C4350
ltimo modo de texto.

Monocromo 40 columnas.
Color 40 columnas.
Color 80 columnas.
EGA 43 filas o VGA 50 filas.
textmode(C40);
Funciones relacionadas: gettextinfo, highvideo, lowvideo, normvideo, textbackground, textcolor.
Funciones relacionadas: gettextinfo, restorecrtmode.
664
wherex
wherey
#include <conio.h>
window
#include <conio.h>
void window(int izda, int arriba, int dcha, int abajo);

int wherex(void);
int wherey(void);
Determina la coordenada x (wherex) y la coordenada y (wherey) de la

posicin del cursor en la ventana actual.
xpos = where(x); ypos = where(y);
Define una regin 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.

Biblioteca de Funciones Estándar Ansi/Iso C++ Y Borland C++ 5.0

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Biblioteca de Funciones Estándar Ansi/Iso C++ Y Borland C++ 5.0

Cargado por

Copyright:

Formatos disponibles

APNDICE F

BIBLIOTECA DE FUNCIONES ESTNDAR

Plantilla referencia de entradas.

Funciones de control de procesos.

FUNCIONES DE ASIGNACIN DE MEMORIA

Esta parte es una revisin breve de la biblioteca de rutinas (funciones) y

PLANTILLA REFERENCIA DE ENTRADAS

Las entradas de las diferentes funciones y macros han sido normalizadas

char *strrev(char *cad)

PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

datos de un programa. Si hay xito se devuelve 0; en caso contrario, 1, y la

Funciones relacionadas: free, farmalloc, malloc, sbrk.

Datos del programa

Despus de asignar partes del segmento de datos a variables estticas y

int allocmen(unsigned t, unsigned * seg);

Asigna memoria principal (un bloque de tamao n.s). El bloque se

Funciones relacionadas free, malloc.

Determina la cantidad de memoria no utilizada. El valor devuelto

Funciones relacionadas: calloc, farcoreleft, malloc.

Funciones relacionadas: falloc frremem, malloc, setblock.

int brk( void* a)

La funcin brk permite modificar el valor break de un programa. El

Esta funcin asigna n piezas de tamao s y las pone a 0. Un puntero al

BIBLIOTECA DE FUNCIONES ESTNDAR ANSI/ISO C++ Y BORLAND C++ 5.0

if(array_grande=farcalloc(20000L, sizeof (int)) NULL)

Funciones relacionadas: farheapfillfree, farheapwalk, heapfillfree, heapcheckfree, heapwalk.

Funciones relacionadas: calloc, farfree, farmalloc, malloc.

int farheapchecknode(void *bloque);

Verifica la consistencia de un solo bloque en el montculo (heap) far.

unsigned long farcoreleft(void);

Determina el nmero total de bytes disponibles en el sistema.

Funciones relacionadas: coreleft, farcalloc, farmalloc.

int farheapfillfree(unsigned int f);

void farfree(void far *b);

Funciones relacionadas: farheapcheckfree, farheapchecknode,

Libera la memoria apuntada por b.

Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.

int farheapwalk(struct farheapinfo *m);

Verifica la consistencia del montculo (heap) far.

Obtiene informacin sobre las entradas en el montculo (heap) far.

Funciones relacionadas: farheapcheckfree, farheapchecknode,

void far *farmalloc(unsigned long n);

int farheapcheckfree(unsigned int f);

Verifica la consistencia de los bloques libres en el montculo (heap) far.

Asigna n bytes de memoria far. La cantidad completa de memoria

Funciones relacionadas: calloc, farfree, farcalloc, malloc.

PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

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

Se utiliza para reasignar (ajustar el tamao de un bloque de memoria b,

int heapcheckfree(unsigned int f);

Verifica la consistencia de los bloques libres en el montculo (heap).

if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL

Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

int heapchecknode(void *n);

Verifica la consistencia de un solo nodo (bloque de memoria). Verifica

vid free(void *dir_memoria);

La funcin free() libera un bloque de memoria. El argumento

da el bloque libre est disponible para asignacin.

free, heapfillfree, heapwalk.

Funciones relacionadas: farheapchecknode, heapcheck, heapcheck-

int heapfillfree(unsigned int f);

Funciones relacionadas: calloc, malloc, realloc

char strrev(char cad)

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

realloc(void b, size_t n);

void bsearch(const voidk, const void b, size_t n, size_t a,

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

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

char strchr(const char cad, int c);

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

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

char strcat(char cad1, const char cad2);

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