Bibliotecas Borland y C++F

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.
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++.
F.2.
FUNCIONES DE ASIGNACIN DE MEMORIA
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
nombre funcin strrev

char *strrev(char *cad)
archivo de cabecera
#include <string.h>
F.1.
PLANTILLA REFERENCIA DE ENTRADAS
sintaxis
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.
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.
Segmento de datos
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>
int *calloc(size_t n, size_t s);
Montculo (heap)
Pila (stack)
Datos del programa 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));
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>
Funciones relacionadas free, malloc.

coreleft #include <alloc.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);
unsigned coreleft(void) // modelos small, tiny, medium unsigned long coreleft(void); // en otros modelos de memoria
Determina la cantidad de memoria no utilizada. El valor devuelto depende del modelo de memoria.
Mem_avail = coreleft();
Funciones relacionadas: calloc, farcoreleft, malloc.

farcalloc
Funciones relacionadas: falloc frremem, malloc, setblock.

#include <alloc.h> brk int brk( void* a) #include <alloc.h> void far *farcalloc(unsigned long n, unsigned long s);
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.
617
if(array_grande=farcalloc(20000L, sizeof (int)) NULL) printf (Fallo en asignacin de memoria\n);
Funciones relacionadas: farheapfillfree, farheapwalk, heapfillfree, heapcheckfree, heapwalk.
Funciones relacionadas: calloc, farfree, farmalloc, malloc.

farheapchecknode farcoreleft unsigned long farcoreleft(void); #include <alloc.h> int farheapchecknode(void *bloque); #include <alloc.h>
Verifica la consistencia de un solo bloque en el montculo (heap) far.

estadoheap = farheapchecknode(arraygrande);
Determina el nmero total de bytes disponibles en el sistema.

memoria_total_disponible = farcoreleft();
Funciones relacionadas: coreleft, farcalloc, farmalloc.

farfree void farfree(void far *b); #include <alloc.h>
farheapfillfree int farheapfillfree(unsigned int f);
#include <alloc.h>
Rellena todos los bloques libres del montculo far con un valor constante.
estadoheap = farheapfillfree(X);
Libera la memoria apuntada por b.

farfree(arraygrande);
Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk.
Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.

farheapcheck int farheapcheck(void); #include <alloc.h>
farheapwalk int farheapwalk(struct farheapinfo *m);
#include <alloc.h>
Obtiene informacin sobre las entradas en el montculo (heap) far.

struct farheapinfo heap_entry; estadopila = farheapwalk(&heap_entry);
Verifica la consistencia del montculo (heap) far.

estadoheap = farheapcheck();
farmalloc void far *farmalloc(unsigned long n);
#include <alloc.h>
Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk, heapcheck.
farheapcheckfree int farheapcheckfree(unsigned int 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);
Verifica la consistencia de los bloques libres en el montculo (heap) far.

estadoheap = farheapcheckfree(F);
Funciones relacionadas: calloc, farfree, farcalloc, malloc.
618
farrealloc
#include <alloc.h>
heapcheckfree int heapcheckfree(unsigned int f);
#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).
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL printf(Fallo reasignacin memoria\n);
Verifica la consistencia de los bloques libres en el montculo (heap).

estadoheap = heapcheckfree(N);
Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.
Funciones relacionadas: calloc, farcalloc, farfree, malloc.

heapchecknode free #include<alloc.h> #include <stdlib.h> int heapchecknode(void *n); #include <alloc.h>
vid free(void *dir_memoria);
Verifica la consistencia de un solo nodo (bloque de memoria). Verifica el bloque de memoria identificado por el puntero n.
estadopila = heapchecknode(array);
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 llamada el bloque libre est disponible para asignacin.
char *cad; // asignar memoria para cadena cad = (char *) malloc(50); ... free(cad); // liberar memoria
Funciones relacionadas: farheapchecknode, heapcheck, heapcheckfree, heapfillfree, heapwalk.
heapfillfree int heapfillfree(unsigned int f);
#include <alloc.h>
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 int heapcheck(void);
#include <alloc.h>
Funciones relacionadas: farheapfillfree, heapcheck, heapcheckfree, heapwalk.
Verifica la consistencia del montculo (heap). En Visual C++ 6.0 la funcin equivalente es _heapcheck();
estadoheap = heapcheck();
heapwalk int heapwalk(struct heapinfo *i);
#include <alloc.h>
Funciones relacionadas: heapcheckfree, heapchecknode, heapfillfree, heapwalk, farheapcheck.
Se utiliza para obtener informacin sobre las entradas en el montculo (heap). La funcin equivalente en Visual C++ es _heapwalk.
619
struct heapinfo i; estadoheap = heapwalk(&i);
setblock int
#include <alloc.h>
Funciones relacionadas: farheapwalk, heapcheck.

malloc #include <stdlib.h> #include <alloc.h>
setblock(unsigned seg, unsigned n);
Ajusta el tamao de un bloque de memoria asignado anteriormente por

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.
bsearch() #include <stdlib.h>
Funciones relacionadas: calloc, free, realloc.

realloc #include <alloc.h> #include <stdlib.h>
void bsearch(const void*k, const void *b, size_t n, size_t a, int(*comparar)(const void*, const void*));
void
*realloc(void *b, size_t n);
Ajusta el 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.
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 Negativo Cero Positivo Condicin Primer elemento menor que el segundo (elem1) (elem2). Los dos elementos son idnticos. Primer elemento mayor que el segundo.
sbrk void *sbrk(int n);
#include <alloc.h>
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.
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: lfind, lsearch, qsort.
Funciones relacionadas: brk, coreleft
620
lfind
#include <stdlib.h>
Valor devuelto Negativo Cero Positivo
Condicin Primer elemento (elem1) menor que el segundo (elem2). Los dos elementos son idnticos. Primer elemento mayor que el segundo.
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);
Ordenar la lista de enteros y visualizar el resultado.

#include <stdlib.h> #include <stdio.h> int comparar(const void*, const void *); int numeros[10] = {4,5,7,3,12,8,6,1,0,2}; main(void) { int i; printf(lista original:); for(i =0; i < 10; i++) printf(%d, numeros[i]); qsort(numeros,10,sizeof(int), comparar); printf(lista ordenada:); for(i = 0; i < 10; i++) printf(%10, numeros[i]); return 0; } // comparar enteros comparar(const void *i, const void *j) { return ((int *)i) ((int *) j) }
Funciones relacionadas: bsearch, lsearch, qsort.

lsearch #include <stdlib.h>
void * lsearch(const void *k, const void *a, size_t *n, size_t W, int(*comparar) (const void*, const void *));
La 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. Funciones relacionadas: bsearch, lfind, qsort.
qsort #include <stdlib.h>
Funciones relacionadas: bsearch, lfind, lsearch.
void qsort(void a, size_t n, size_t w, int(*comparar) (const void*, const void*));
F.4.
FUNCIONES DE CADENA
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:
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;
621
Acceso a las cadenas
strchr char *strchr(const char *cad, int c);
#include <string.h>
A las cadenas se accede directamente a travs de su ndice, como en el ejemplo anterior, o bien a travs de un puntero.
char cad5[] = Hola Mortimer; char *p_cad5; p_cad5 = cad5;
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). printf(%s, strchr(Salario mensual = $85725, $));
Se puede tambin declarar e inicializar una cadena a la vez:

char *p_cad5 = Hola Mortimer;
visualizar $85725
char *s[81] = Esta es una cadena de prueba; char *ptr; ptr = strchr(s, a);
El archivo de cabecera <string.h> contiene numerosas funciones que manipulan cadenas.

stpcpy
el valor almacenado en ptr es un puntero a la primera aparicin de a.

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

> 0 si a > b = 0 si a == b < 0 si a < b i = strcmp(MNP, mnp); i = strcmp(abc, abc); i = strcmp(xy, abc); char s1[80] Mayo; char s2[80] = Octubre; int j; j = strcmp(s1, s2); // resultado < 0 // resultado = 0 // resultado > 0
Funciones relacionadas: strcat, strcpy, strncat, strncpy, strdup.

strcat
#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: strcmpi, stricmp, strnicmp, strncmp.
strcmpi
#include <string.h>
int strcmpi(const char *cad1, const char * call2);
Funciones relacionadas: strcpy, strdup, strncat, strncpy.
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 v = strcmpi(c1, c2);
ce del primer carcter de cad1, que pertenece al conjunto de caracteres de cad2.

primero = strcspn(circunloquio, q); // primero = 8
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.

strcoll #include <string.h>
Funciones relacionadas: strpbrk, strspn.

strdup char * strdup(const char *cad); #include <string.h>
int strcoll(const char *cad1, const char cad2);
Compara cad1 con cad2. Devuelve un valor.

< 0 si cad1 < cad2 = 0 si cad1 = cad2 > 0 si cad1 > cad2 if(strcoll(nombre1, nombre2)! = 0) exit(EXIT_FAILURE);
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).
Leer una cadena y hacer un duplicado.

#include <stdio.h> #include <string.h> main() { char cad1[80], * cad1_copia; printf(Introduzca una cadena:); gets(cad1); cad1_copia = strdup(cad1); printf(La cadena duplicada es:%s\n, cad1_copia); return 0; }
Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp,

strxfrm.
strcpy()
#include <string.h>
char *strcpy(char *cad1, const char *cad2); strcpy() copia cad2 en cad1. Si la longitud de la cadena resultante excede el tamao asignado a cad1, puede producir fallos en el programa. char *a = Pepe Luis; char b[12]; strcpy(b, a); cout << b << \n;
strerror char *strerror(int errnum);
#include <string.h>
Funciones relacionadas: strcat, strcup, strncat, strncpy.

strcspn #include <string.h>
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);
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-
Funciones relacionadas: perror, _strerror.
623
strerror
#include <string.h> #include stdio.h
strlwr char *strlwr(char *cad);
#include <string.h>
char *strerror(const char *cad);
Esta funcin sirve para generar un mensaje de error definido por el usuario.
printf(%S, _strerror(error apertura archivo));
Convierte una cadena en letras minsculas. La funcin devuelve un puntero a la cadena convertida.
char *orden =SALIR; strlwr(orden); // ahora orden = salir;
Funciones relacionadas: perror, strerror.
Funciones relacionadas: strupr, toloweer.

strncat #include <string.h>
stricmp
#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.
Si cad1 = cad2 Si cad1 < cad2 Si cad1 > 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.
char *a = Sierra Madre; char *b = de la ciudad de Monterrey; cout << strncat(a, b, 4) << \n; cout << strncat(a, b) << \n;
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),
Funciones relacionadas: strcat, strdup, strcpy, strncpy.
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.

strncmp strlen size_t strlen(const char *cad); #include <strign.h> #include <string.h>
int strncmp(const char *cad1, const char *cad2, size_t n);
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));
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)
Funciones relacionadas: _fstrlen.
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.
char *nombrearch = c: /usr/tst/libro/cap1.txt; cout << (strrchr(nombrearch, /)+1 << \n;
Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, strnicmp.
Funciones relacionadas: strchr.

strnset #include <string.h> strrev char *strrev(char *cad); #include <string.h>
char *strnset(char *cad, int c, size_t n);
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.
printf(Introduzca una cadena:); gets(cadena); printf(Introducir un carcter:); c = getche(); long = strlen(cadena)/2; strnset(cadena, c, lon);
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] printf(Introduzca una cadena:); gets(demo); strrev(demo); printf(La cadena inversa es:\n %s |\n, demo); return 0; }
Funciones relacionadas: memset, setmem, strset.
strpbrk
#include <string.h>
char *strpbrk(const char *cad1, const char *cad2);
Funciones relacionadas: strcpy, strncpy.
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).
char *s = Mortimer L.J. Mackoy; char *p = strpbrk(s, L4); cout << p << \n; // la salida es L.J.Mackoy
strset char *strset(char *cad, int c);
#include <string.h>
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.
#include <string.h> char *cad = -----; strset (cad, x); // cad es ahora xxxxx
strrchr char *strrchr(const char *cad, int c);
Funciones relacionadas: strnset.
625
strspn
#include <string.h>
sze_t strspn(const char *cad1, constchar *cad2);
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.
strupr(sierra madre); // SIERRA MADRE
Localiza la posicin del primer carcter de una cadena (cad1) que no pertenece al conjunto de caracteres de otra (cad2).
loc = strspn (cad1, blanco);
Funciones relacionadas: strlwr, toupper.

strxfrm #include <string.h>
Funciones relacionadas: strcmp, strcspn.
strstr
#include <string.h>
size_t strxfrm(char *cad1, char *cad2, size_t n);
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;
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);
Funciones relacionadas: strchr, strcspn, strpbrk

strtok #include <string.h>
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.
isalnum int isalnum(int c); #include <ctype.h>
iscntrl, isdigit isgraph, islower isprint, ispunct, isspace isupper,isxdigit int int int int int int int int int 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);
#include <ctype.h>
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 int isalpha(int c); #include <ctype.h>
Estas macros sirven para determinar propiedades especficas de un carcter ASCII.
Macro
iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit
Verifica Carcter de control. Dgito decimal. Carcter imprimible (sin espacio). Carcter minscula. Carcter imprimible Carcter puntuacin Carcter blanco. Carcter mayscula. Dgito hexadecimal.
Rango vlido de valores

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
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 int isascii(int c); #include ctype.h>
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.
carac = getch(); if(isascii(carac)) printf(%c es ASCII \n, carac); else printf(%c no es ASCII \n, carac);
Cada macro (funcin) devuelve un valor distinto de cero si c satisface el criterio de esa macro; en caso contrario, devuelve un cero.
if(isprint(c)) if(iscntrl(c)) if(isdigit(c)) if(islower(c)) 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)
Funciones relacionadas: toascii, isalnum, isdigit,
627
toascii int toascii(int c);
#include <ctype.h>
F.6.
FUNCIONES DE CALENDARIO (FECHA Y HORA)
Esta funcin convierte un valor entero en un carcter ASCII vlido.

C = toascii(entero);
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.
asctime char *asctime(const struct tm *hora); #include <time.h>

_tolower tolower int _tolower(int c); int tolower(int c);
#include <ctype.h>
Convierte la fecha y la hora almacenada en una estructura de tipo tm en una cadena de caracteres. La estructura tm se define en time.h as:
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
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
Funciones relacionadas: iascii, _toupper, toupper.

printf(Fecha/hora es %s\n, asctime(&reloj)); _toupper touper int _toupper(int c); int _toupper(int c); int c; // carcter a convertir
Funciones relacionadas: ctime, gmtime, clocaltime, strftime,

#include <ctype.h> time.
clock cock_t clock(void);
#include <time.h>
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
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: iascii, _tolower, tolower.
Funciones relacionadas: gettime, time.
628
ctime
#include <time.h>
ftime void ftime(struct timeb *ptrhora);
#include <sys/timeb.h>
char *ctime(const time_t *hora);
Convierte la fecha y hora almacenada como valor de tipo time_t en una cadena de caracteres (mes da hora ao\0).
time_t hora; hora = time(NULL); printf(Hora actual=%s\n, ctime(&hora));
Obtiene la hora actual y la almacena en la estructura timeb apuntada por ptrhora.

struct timeb { long time; short millitm; short timezone; short dstflag; }; // // // // // segundos desde 00:00:00 hora GMT milisegundos diferencia en minutos hora Greenwich y hora local hora de verano, ahorro de luz
Funciones relacionadas: asctime, ftime, strtime, time.

difftime double #include <time.h> difftime(time_t hora2, time_t hora1);
ftime(&hora);
Funciones relacionadas: time tzset.

getdate void getdate(struct date *f); #include <dos.h>
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));
Obtiene la fecha del sistema. Los componentes se almacenan en la estructura date definida en dos.h.
struct date { int da_year; char da_day; char da_mon; }; struct date fecha; getdate(&fecha); // ao actual (1980-2099) // dia mes (1-31) // mes (1-12)
Funciones relacionadas: asctime, ctime, gmtime, localtime,

tzset.
dostounix
#include <dos.h>
long dostounix(struct date *f, struct time *h);
Funciones relacionadas: dostounix, gettime, setdate, settime.

gettime void gettime(struct time *t); #include <dos.h>
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en formato UNIX.
time_t t; struct time dos_hora; struct date dos_fecha; gatdate(&Dos_hora); gettime(&dos_fecha); t = dostounix(&dos_fecha, &dos_hora);
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)
Funciones relacionadas: ctime, gatdate, gettime.
629
unsigned char ti_hour unsigned char ti_hund unsigned char ti_sec }; struct time hora; gettime(&hora);
// horas (0-23) // centsimas de segundo (0-99) // segundos (0-59)
setdate void setdate(struct date *f);
#include <dos.h>
Cambia la fecha actual del sistema. Los componentes de la fecha (da, mes. Ao) se especifican en los campos de la estructura date.
struct date { int da_year; char da_day; char da_mon; }; // ao actual // da mes // mes, 1 para enero, 2...
Funciones relacionadas: dostounix, getdate, setdate, settime.
gmtime
#include <time.h>
struct tm *gmtime (const time_t *hora);
En Visual C++ la funcin equivalente es _dos_setdate.

setdate(&fecha);
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.
ahora = gmtime(&hoy);
Funciones relacionadas: getdate, gettime, settime, dostounix.

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.
settime(&hora);
struct tm *localtime(const time_t *hora);
Convierte una fecha y hora en varios campos de una estructura de tipo tm. Vase struct tm en asctime.
tiempoactual = localtime(&ahora);
Funciones relacionadas: dostounix, gatdate, gettime, setdate.

stime int stime(time_t *t); #include <time.h>
Funciones relacionadas: asctime, gmtime, time.
mktime time_t mktime(struct tm *h);
#include <time.h>
Establece la fecha y hora del sistema al valor contenido en la posicin cuya direccin est en el argumento t.
time_t horasis; horasis = time(NULL); stime(&horasis); printf(segundos desde 1/1/70 %ld, horasis);
Convierte la hora local a un valor de calendario. Vase struct tm en

asctime.
Funciones relacionadas: asctime, gmtime, localtime, time.
Funciones relacionadas: dostounix.
630
strftime
#include <time.h>
Convierte a formato DOS un valor de hora en el formato UNIX.

tnixtodos(t_unix, &d_dos, ft_dos);
size_t strftime(char *cad, size_t maxlon, const char *formato, const struct tm *t);
Funciones relacionadas: getdate, gettime, time, setdate, settime. Convierte un puntero en una estructura tm en una cadena cad (con una longitud 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);
F.7.
FUNCIONES DE CONTROL DE DIRECTORIOS
Funciones relacionadas: asctime, ctime, gmtime, localtime,

time.
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.
chdir #include <dir.h>
time time_t time(time_t *h);
#include <time.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);
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); }
tzset void tzset(void);
#include <time.h>
Establece las variables de entorno horarios TZ; asigna valores a las variables globales timezone, daylight y tzname.
tzset(); printf(Luz de verano = %d\n, daylight); printf(zona horario = %ld\n, timezone);
Funciones relacionadas: mkdir, rmdir, setdisk, system.

findfirst #include <dir.h>
Funciones relacionadas: asctime, ftime, gmtime, localtime,

time.
int findfirst(const char *camino, struct ffblk *ffblk, int atrib);
unixtodos void
#include <time.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
unixtodos(long time, struct date *f, struct time *h);
631
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
#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
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).
h = fnsplit(camino, unidad, dir, nomarch, ext);
Archivo de slo lectura. Archivo oculto. Archivo del sistema. Etiqueta de volumen. Directorio. Bit de archivo activado.
Funciones relacionadas: fnmerge.
struct ffblk ffblk; int t; t = findfirst(*.*, &ffblk,0);
getcurdir int getcurdir(int u, char *dir);
#include <dir.h>
Funciones relacionadas: findnext.

findnext int findnext(struct ffblk *ffblk); 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(). findnext(&filefinfo); #include <dir.h>
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);
Funciones relacionadas: getcwd, getdisk.
getcwd
#include <dir.h>
Funciones relacionadas: findfirst.

char *getcwd(char *camino, int numcar); fnmerge #include <dir.h> getcwd obtiene el nombre de camino completo del directorio de 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. getcwd(cuentas, 80)
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).
fnmerge(camino, c:, \\aux\\,demo,.dat);
Funciones relacionadas: fnsplit.
Funciones relacionadas: chdir.
632
getdisk int getdisk(void);
#include <dir.h>
Funciones relacionadas: chdir, rmdir.

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

mdir int rmdir(const char *camino); #include <dir.h> searchpath char searchpath(const char *nombre); #include <dir.h>
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:
EACCES ENOENT
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.
buffer = searchpath(BC.EXE);
Permiso denegado. Camino archivo no encontrado. Esta funcin es similar a RMDIR o RD de MS-DOS.
Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la variable de entorno PATH.

buffer = searchpath(autoexec.bat);
rmdir(C:\\PRUEBAS); Supresin de directorio PRUEBAS
Funciones relacionadas: chdir, mkdir.

mkdir int mkdir(const char *camino); #include <dir.h>
Funciones relacionadas: getenv, putenv.

setdisk int setdisk(int unidad);
#include <dir.h>
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
Cambia a una nueva unidad por omisin. El valor de la unidad (unidad) es un entero. Unidad A B: C: D: ...
nuevaunidad = setdisk(3); / nueva unidad actual es C:
Permiso denegado. Camino no encontrado.
resultado = mkdir(PRUEBAS); // crea el directorio PRUEBAS
Funciones relacionadas: getdisk
633
F.8.
FUNCIONES DE CONTROL DE PROCESOS
atexit int atexit(void(*func)(void));
#include <stdlib.h>
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.
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 <process.h> #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); int execvp(char *camino, char *argv[]); int execvpe(char *camino, char *argv[], char **env);
void abort(void);
Termina la ejecucin del programa actual y devuelve un cdigo de error (3).

if (argc 1) { printf(Faltan argumentos!\n) abort()
}
Funciones relacionadas : exit, _exit, raise, signal, spaw.
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.
execlo(hijo.exe, hijo.exe, Uno, Dos, NULL); execv(hijo.exe, argv);
Funciones relacionadas: abort, atexit, exit, _exit, fpreset, spawn.

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

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.
exit(0);
Funciones relacionadas: abort, raise, signal.
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 void _exit(int estado);
#include <stdlib.h>
Funciones relacionadas: setlocale.

longjmp void longjmp(jmp_buf env, int valor); #include <setjmp.h>
Termina inmediatamente el proceso actual sin hacer otras operaciones auxiliares (como cierre de archivos).
_exit(0)
Funciones relacionadas: exit.

getenv char *getenv(const char *nomvar); #include <stdlib.h>
Restaura el estado de la pila y la ejecucin local anteriormente grabada en env por setjmp.
longjmp(plaza, 3);
Funciones relacionadas: setjmp.

perror void perror(const char *cadena); #include <stdio.h>
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 unsigned getpid(void) #include <process.h>
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);
Funciones relacionadas: _strerror, strerror.

putenv int putenv(const char *cadena); #include <stdlib.h>
Obtiene el ID de proceso de un programa. Est disponible en sistemas UNIX.

printf(PID:%X\n,getpid());
Funciones relacionadas: getpsp.

localeconv struct lconv *localeconv(void); #include <locale.h>
Crea nuevas variables de entorno o modifica los valores de las variables de entorno existentes.
if(putenv(argv[1] == -1)
Funciones relacionadas: getenv.
635
raise int raise(int seal);
#include <signal.h>
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);
int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL, char **envp[]); int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL); int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL, char **envp[]); int spawnv(int modo, char *camino, char *argv[]); int spawnve(int modo, char *camino, char /argv[], char *envp[]); int spawnvp(int modo, char *camino, char *argv[]); int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);
La familia de funciones spawn crea y ejecuta un nuevo proceso hijo. Debe haber memoria suficiente para cargar y ejecutar el proceso hijo.
spawnlpe(P_WAIT, hijo.exe, hijo.exe, spawnlpe, buf, NULL, env);
Funciones relacionadas: abort, signal.

setjmp int setjmp(jmp_buf env); #include <setjmp.h>
Funciones relacionadas: exec.
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);
F.9.
FUNCIONES DE CONVERSIN DE DATOS
Funciones relacionadas: longjmp.

signal #include <signal.h>
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.
atof()
void (*signal(int sig, void (*func) (int))) (int);
#include <math.h> #include <stdlib.h>
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.
signal(SIGINT, SIG_IGN);
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: [blanco][signo][ddd][.]]ddd][exponente][signo][ddd]
Funciones relacionadas: abort, _control87, exit, longjmp, raise,

setjmp.
opcional blancos o tabulaciones dgitos decimales
e/E
spawn (funciones)
#include <stdio.h> #include <process.h>
int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);
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 long int i; char cad_ent = 9876543; ... i = atol(cad_ent); // convierte cadena 9876543 a entero // largo.
Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf,

strtod.
atoi int atoi (const char *cadena)
Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod,

#include <stdlib.h> strtol, strtoul, ultoa.
La funcin atoi() convierte el argumento cadena en un valor entero. La cadena debe tener el siguiente formato: [espacio en blanco][signo][ddd] opcional espacio o tabulacin dgitos decimales
ecvt
#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).
p_buffer = ecvt(valor, exactitud, &dec, &signo);
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.
int i; char *cad_ent =123; ... i = atoi(cad_ent);// convierte la cadena 123 al entero 123
Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa,

ltoa, ultoa.
fcvt
#include
<stdlib.h>
Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.

atol long atol(const char *cadena); #include <stdlib.h>
char *fcvt(double valor, int n, int *dec, int *signo);
Convierte el argumento cadena en un valor entero largo. La cadena debe tener el formato: [espacio en blanco][signo][ddd]
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.
cadena = fcvt(valor, exactitud, %oposicin_d, &signo);
opcional blancos y tabulaciones dgitos decimales
Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,

sprintf, ultoa.
637
gcvt
#include <stdlib.h>
strtod
#include stdlib.h>
char *gcvt(double valor, int ndig, char, *buf);
double strtod(const char *cad, char **p);
La 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);
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]
+, blanco/ tabulacin
d, D, e, E dgitos decimales
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf,

sprintf, ultoa.
itoa
#include stdlib.h>
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. #include <stdio.h> #include <stdlib.h> main() { double x; char *num_flt = 843899.567: char *p; x = strtod(num_flt, &p); printf(x = %f\n,x); }
char *itoa(int valor, char *cad, int base);
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.
itoa(32, buffer, 16); // buffer contendr 20, ya que 32 entero // equivale a 20 en hexadecimal
Funciones relacionadas: atoi, atol, itoa, ultoa.
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.
ltoa
#include <stdlib.h> strtol #include <stdlib.h>
char *ltoa(long valor, char * cad, int base);
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);
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 octal dgitos decimales hexadecimal
Funciones relacionadas: atoi, atol, itoa, ultoa.
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 <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
#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).
ultoa(valor, buffer, base);
Funciones relacionadas: itoa, ltoa.
F.10.
FUNCIONES DE ENTRADA/SALIDA
Funciones relacionadas: atoi, atof, atol, ltoa, strtoul.
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: 1. Secuencias o flujos (stream). 2. Bajo nivel. 3. Consola y puertos.
Funciones de flujos (stream)
strtoul
#include <stdlib.h>
unsigned long strtoul(const char *cad, char **p, int base);
Convierte una cadena de caracteres a un entero largo sin signo en la base dada. La cadena debe tener el formato: [espacio en blanco][0][x|X][ddd] 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.
i = strtoul(cad_ent, &ptrfin, base);
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 clearerr(FILE *f); #include <stdio.h>
Reinicializa el indicador de error de un flujo f.

clearerr(fichen);
Funciones relacionadas: atol, ultoa, strtol.
Funciones relacionadas: eof, feof, ferror, perror.
639
fclose, fcloseall int fclose(FILE *f); int fcloseall(void);
#include <stdio.h>
fflush int fflush(FILE *f);
#include <stdio.h>
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.
fcloseall();
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);
Funciones relacionadas: close, fdopen, fopen.

fdopen FILE *fdopen(int handle, char *modo); #include <stdio.h>
Funciones relacionadas: fclose, flshall, fopen.

fgetc int fgetc(FILE * f); #include <stdio.h>
Abre un flujo utilizando un handle (entero devuelto por las rutinas de E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una estructura de datos FILE con el archivo especificado por handle.
p_datos = fdopen(handle, rb);
Lee un carcter de la posicin actual del archivo y, a continuacin, incrementa esta posicin.
c = fgetc(fp)
Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc, Funciones relacionadas: fclose, fopen, fropen, open.
feof int feof(FILE *flujo); #include <stdio.h> putchar.
fgetchar #int fgetchar(void);
#include <stdio.h>
Comprueba el final de archivo de un flujo.

feof(fichen);
Lee un carcter del archivo stdin, normalmente el teclado.

c = fgetchar();
Funciones relacionadas: clearerr, fclose, rewind.

ferror int ferror(FILE *f); #include <stdio.h>
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.

fgetpos int fgetpos(FILE *flujo, fpos_t *p); #include <stdio.h>
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.
fgetpos(fp, &pos_archivo);
Funciones relacionadas: clarerr, eof, feof, fopen, perror.
640
fgets
#include <stdio.h> *f);
if ((corriente2 = fopen(datos, W+)) == NULL printf(el archivo..no se ha abierto \n);
char *fgets(char *cad, int n, FILE
Funciones relacionadas: fclose, fcloseall, fdopen, ferror,

fileno, freopen, open, setmode.
Lee una cadena de un flujo (hasta que se encuentra \n, o el nmero mximo de caracteres especificados).
fgets(caddemo,80, fp);
flushall int flushall(void);
#include stdio.h>
Funciones relacionadas: fputs, gets, puts.

fileno int fileno(FILE *f); #include <stdio.h>
Vaca (limpia) todos los buffers asociados con los archivos abiertos.
numvaciados = flushall();
Funciones relacionadas: fclose, fflush.
Obtiene el mando o manejador (handle) del archivo asociado con un flujo.

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

fopen #include <stdio.h> fprintf(f1,El resultado es %f\n,result);
FILE *fopen(const char *f, const char *modo);
Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
Abre un archivo f. La cadena de caracteres modo especifica el tipo de acceso.

Modo
r w a r+ w+ a+ rb wb ab rb wb ab
fputc int fputc(int c, FILE *f);
#include <stdio.h>
Accin 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.
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>
641
Escribe el carcter c en stdout.

fputchar(q);
Lee datos con formato de un flujo.

fscanf(flujo, %s%f, cad, &f);
Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.

fputs int fputs(const char *cad, FILE *f); #include <stdio.h>
Funciones relacionadas: csanf, fprintf, scanf, sscanf.

fseek int fseek(FILE *f, long desp, int org); #include <stdio.h>
Escribe una letra cad en un flujo f. Devuelve el ltimo carcter impreso, si hay error devuelve EOF.
fputs(esto es una prueba, f1);
Mueve el puntero del archivo asociado con f a una nueva posicin que est desplazada desp bytes de org.
Origen
SEEK_SET SEEK_CUR SEK_END
Significado Principio de archivo. Posicin actual puntero archivo. Final de archivo.

// ir al principio
Funciones relacionadas fgets, gets, puts.

fread #include <stdio.h>
fseek(f1,OL,SEEK_SET); 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 int fsetpos(FILE *f, const fpos_t *p); #include <stdio.h>
Funciones relacionadas: fwrite, read.

freopen #include <stdio.h>
Establece la posicin del puntero del archivo al lugar especificado por el objeto apuntado por p.
fsetpos(fp, &posarch);
FILE *freopen(const char *f, const char *m, FILE *flujo);
Cierra el archivo asociado con flujo y reasigna flujo al archivo especificado por f. Los modos (m) utilizados son los mismos de fopen.
freopen(salida.txt, w, stdout);
Funciones relacionadas: getpos.

ftell long int ftell(FILE *f); #include <stdio.h>
Funciones relacionadas: fclose, fopen.

fscanf #include <stdio.h>
Obtiene la posicin actual (puntero) del archivo asociado con el flujo f.

ftell(fichen);
int fscanf(FILE *f, const char *formato [, direccin,...]);
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.

int c; while((c = getchar())!= \n) printf(%c, c);
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);
Funciones relacionadas: fgetc, fgetchar, getch, getche, putc,

putchar, ungetc.
Funciones relacionadas: fread, fscanf, getc, fgetc.

getche getc int getc(FILE *f); #include <stdio.h> int getche(void); #include <stdio.h>
Lee un carcter del teclado haciendo eco del carcter en la pantalla.

resp= getche();
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); }
Funciones relacionadas: cgets, getch, getchar, ungetch.
gets char *gets(char *cad);
#include <stdio.h>
Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc,

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

do { car = getch(); char = toupper(car); } while(car != S);
Funciones relacionadas: fgets, fputs, puts.
getw int getw(FILE *f);
#include <sdio.h>
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.
643
printf
#include <stdio.h>
puts int puts(const char *cad);
#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).
Cdigo
%c %d %e %f %s %x
Escribe una cadena en el archivo de salida estndar stdout.

puts(Desea continuar(s/n?);
Formato Carcter. Entero decimal. Real (double o float), notacin cientfica. Coma flotante. Cadena de caracteres. Hexadecimal sin signo.
Funciones relacionadas: fgets, fputs, gets.

putw int putw(int i, FILE *f); #include <stdio.h>
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.

rewind void rewind(FILE *f); #include <stdio.h>
Funciones relacionadas: fprintf, scanf, sprintf, viprintf,

vprintf, vsprintf.
putc, putchar int putc(int c, FILE *f); int putchar(int c);
#include <stdio.h>
Reinicializa el puntero del archivo al principio de un flujo.

rewind(fx);
Funciones relacionadas: fseek.

scanf #include <stdio.h>
Escribe un carcter en un flujo (putc) o en stdout (putchar).

putc(*, demo); int scanf(const char *formato[,direccin,...]);
Funciones relacionadas: fputc, fputchar, getc, getchar.
Lee datos con formato del flujo de entrada estndar.

Cdigo Formato Carcter. Entero decimal. Hexadecimal. Entero decimal. Nmero real. Octal. Puntero. Cadena.
putch int putch(int c);
#include <stdio.h>
%c %d %x %i %f %o
Escribe un carcter en la pantalla.

putch(B);
%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 void setbuf(FILE *f, char *buffer); #include <stdio.h> tmpfile FILE *tmpfile(void); #include <stdio.h>
Asigna un buffer a un flujo.

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

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

setvbuf #include <stdio.h>
Funciones relacionadas: tmpnam.

int setvbuf(FILE *f, char *b, int t, size_t l); tmpnam char *tmpnam(char *s); #include <stdio.h>
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.
setvbuf(demo, buffer, _IOFBF, 120);
Genera un nico nombre de archivo y lo guarda en el array apuntado por s.

tmpnam(prueba);
Funciones relacionadas: setbuf. Funciones relacionadas: tmpfile.

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

vsprintf.
Funciones relacionadas: getc.

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

char ch; ch = getch(); ungetch(ch);
vsscanf
#include <stdio.h> #include <stdarg.h>
int vsscanf(const char *b, const char *f, lista_va lista_arg); #include <stdio.h> #include <stdarg.h>
vfprintf, vprintf, vsprintf
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);
Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.

Funciones de bajo nivel
Escribe salida con formato utilizando un puntero a una lista de argumentos.

vprintf(formato, nota);
Funciones relacionadas: fprintf, printf, sprintf, va_arg,

va_end, va_strat.
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.
vfscanf
#include <stdio.h> #include <stdarg.h>
_close, close int _close(int h); int close(int h);
#include <io.h>
int vfscanf(FILE *F, const char *f, lista_va lista_arg);
Lee entrada con formato de un flujo, tal como scanf, excepto que vfscanf acepta un puntero a la lista de argumentos. vfscanf(demo, formato, arg);
Cierra el archivo especificado en h. Estas funciones se utilizan con

_open y open. close(f1);
Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf.

vscanf #include <stdio.h>
Funciones relacionadas: fclose, fopen, open.
int vscanf(const char *f, lista_va lista_arg);
_creat creat
#include <io.h> #include <sys\stat.h> #include <dos.h>
Lee una entrada con formato de un flujo; similar a scanf, excepto que
vscanf acepta un puntero a la lista de argumentos. vscanf(formato, argumento);
int creat(const char *cam, int modo); int _creat(const char *cam, int atributo);
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
S_IWRITE S_IREAD S_IREAD|S_IWRITE
Significado Permiso de escritura. Permiso de lectura. Permiso de lectura y escritura.
eof int eof(int d);
#include <io.h>
fh= creat(datos,S_IREAD|S_IWRITE);
Funciones relacionadas: chmod, close, open umask.

creatnew #include <io.h> #include <dos.h>
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))
Funciones relacionadas: feof, ferror, perror.

lseek #include <io.h> #include <stdio.h>
int creatnew(const char *camino, int atributo);
Crea un archivo nuevo con los atributos especificados.

h = creatnew(F.FIL,0);
long lseek(int d, long desp, int origen);
Funciones relacionadas: _creat, fopen, open.

creattemp #include <io.h> #include <dos.h>
La funcin lseek mueve el puntero asociado con el descriptor d a una nueva posicin que est emplazada desp bytes de origen.
pos = lseek(fh, OL, SEEK_CUR);
Funciones relacionadas: fseek, tell.

open #include <fcntl.h> #include <io.h> #include <sys\stat.h>
int
creattemp(char *camino, int atributo);
Crea un nico archivo temporal con byte de atributo en el directorio escrito por camino.
if((h = creattemp(nombre,9))== -1
int open(const char *f, int a[, unisgned m]);
Funciones relacionadas: tmpfile.

dup, dup2 int dup(int h); int dup2(int h1, int h2); #include <io.h>
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.
Indicador Lectura/escritura
O_RDONLY O_WRONLY O_RDWR O_NDELAY O_APPEND O_TRUNC O_EXCL
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.
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace de archivo (dup2).
viejostdout = dup(STDOUT); dup2(fptr, STDOUT);
Funciones relacionadas: close, creat, open.
O_BINARY O_TEXT
647
open(OPEN.OUT, 0_WRONLY|O_CREAT, S_IREAD|IWRITE); if((h = open(open.tst, O_CREAT))==1)...
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.
Indicador Lectura/escritura
O_RDONLY O_WRONLY O_RDWR S_IWRITE S_IREAD S_IWRITE|S_IREAD
Escribe datos en un archivo (lon bytes en el archivo asociado con d desde el buffer apuntado por buffer).
write(fx, grande, 60000);
Significado Abrir para lectura. Abrir para escritura. Abrir para lectura y escritura. Acceso de escritura. Acceso de lectura. Acceso de lectura y escritura.
Funciones relacionadas: creat, open, read, sopen.

Funciones de consola y puertos de E/S
Las funciones de E/S sirven para interactuar con el teclado y la pantalla. Estas funciones se declaran en el archivo de cabecera conio.h.
cgets df = sopen(C:||autoexec.bat, O_RDONLY, SH_DENYRW, S_IREAD); char *cgets(char *cadena);
#include <conio.h>
Funciones relacionadas: close, fopen.

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

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). cprintf(Cubo de %2d es %rd\r\n,i, i * i * i);
getpass char *getpass(const char *indicador);
#include <conio.h>
Funciones relacionadas: printf.
Lee una palabra de paso por consola, que no se visualiza en pantalla (menos de ocho caracteres de longitud).
palabrapaso = getpass(Introduzca clave);
cputs int cputs(const char *cad);
#include <conio.h>
Funciones relacionadas: getch
Escribe una cadena en la pantalla. No se enva ningn carcter de nueva lnea despus de la cadena.
cuts(Est usted seguro(s/n)?);
inport, inportb int inport(int puerto); unsigned char inportb(int puerto);
#include <dos.h>
Funciones relacionadas cprintf.
cscanf int
#include <conio.h>
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);
cscanf(char *formato [,direccin,...]);
Lee caracteres con formato directamente desde la consola en la posicin dada por direccin.
cscanf(%d%d%d, &dia, &mes, &hora);
Funciones relacionadas: outport, poutportb.
kbhit int kbhit(void);
#include <conio.h>
Funciones relacionadas: fscanf, scanf, sscanf.
Comprueba si se ha pulsado recientemente una tecla.

get, getche int getch(void); int getche(void); #include <conio.h> // 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(); outport, outportb #include <conio.h>
Funciones relacionadas: cgets, getchar, ungetch.
void outport(int puerto, int palabra); void outportb(int puerto, unsigned char byte);
649
Escribe una palabra de 16 bits (outport) un byte (outportb) en un puerto de E/S.

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

Modo
00 01 02 04 06
Significado Se verifica existencia del archivo. Ejecutar. Verifica permiso de escritura. Verifica permiso de lectura. Verifica permiso de lectura y escritura.
Funciones relacionadas: inp, inport, inportb, inpw.

putch int putch(int c); #include <conio.h>
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 int ungetch(int c); #include <conio.h>
chmod
#include <stdio.h> #include <sys\stat.h>
int chmod(const char *camino, int pmodo);
Cambia los permisos de lectura/escritura de un archivo.

r = chmod(prueba.tst, S_IREAD);
Sita un carcter en el buffer del teclado de modo que es el siguiente carcter ledo en la consola.
if(c =!EOF) ungetch(c); ungetch(car);
Funciones relacionadas: access, fstat, stat.

pmodo
S_IWRITE S_IREAD S_IREAD|S_IWRITE
Funciones relacionadas: getch, getche, ungetc.
Permiso de acceso Escritura. Lectura. Lectura/Escritura.
F.11.
FUNCIONES DE GESTIN DE ARCHIVOS

chsize
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.
access int access(const char *nomarch, int modo); #include <io.h>
#include <io.h>
int chsize(int manejador, long longitud);
Cambia el tamao del archivo.

chsize(fh, 5);
Funciones relacionadas: access, chmod, fstat, stat.
650
filelength long filelenght(int manejador);
#include <io.h>
Devuelve informacin sobre el archivo especificado en la estructura de tipo stat apuntada por buffer. La estructura stat es:
struct stat { short st_dev; short st_ino; short st_mode short st_nlink; int st_uid; int st_gid; int st_rdev; long st_size; long st_atime; long st_mtime; long st_ctime; }; fstat(fich, &info); // // // // // // // // // // // unidad o dispositivo 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
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
Funciones relacionadas: access, chmod, stat.
isatty int isatty(int h);
#include <io.h>
Funciones relacionadas: fnsplit.
Determina si es un dispositivo orientado a carcter (terminal, consola, impresora o puerto serie).

fnsplit #include <dir.h> if(isatty(fileno(stdout))) puts(es consola);
int fnsplit(const char *camino, char *unidad, char *dir, char *fnombre, char *ext);
Separa un nombre de camino completo en sus componentes: letra, unidad, camino, nombre y extensin del archivo.
f = fnsplit(c, unidad, dir, arch, ext);
lock int lock(int h, long d, long n);
#include <io.h>
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.
#include <sys\stat.h> res lock(h, 0L,256);
fstat
bloque de 256 bytes
int fstat(int h, struct stat *buffer);
Funciones relacionadas: sopen, unlock.
651
mktemp char * mktemp(char *plantilla);
#include <dir.h>
modo 0_BINARY(binario) 0_TEXT(texto) setmode(fileno(stdin), 0_BINARY); // modo binario
Crea un nico nombre de archivo modificando una plantilla dada como argumento, plantilla toma la forma basexxxxxx, donde base es el nombre que se proporciona y x los caracteres a modificar.
char modelo = tcbxxxxxx; mktemp(modelo);
Funciones relacionadas: fopen, open.

stat #include <sys\stat.h>
int stat(char *f, struct stat *buffer);
Funciones relacionadas: tmpfile, tmpnam.
Obtiene informacin sobre el estado de un archivo existente f.

resultado = stat(stat.c,&buf);
remove int remove(const char *camino);
#include <stdio.h>
Funciones relacionadas: access, chmod, fstat.

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

unsigned umask(unsigned Pmodo); remove(C:\\ux\\demo); // borra demo
Funciones relacionadas: unlink.
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);
rename
#include <stdio.h>
int rename(const char *vn, const char *nn);
Funciones relacionadas: chmod, creat, mkdir, open, sopen.

unlink
Renombre el archivo vn a nn.

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

setmode #include <io.h> #include <fcntl.h> result = unlink (demo.jnk); if (result==0) printf (unlink tuvo xito);
int setmode(int h, int modo);
Permite cambiar el modo del archivo abierto entre texto y binario.
Funciones relacionadas: remove.
652
unlock
#include <conio.h>
Las funciones complejas son propias de Borland C++ y no son exportables.

Clase bcd
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.
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.
F.12.
FUNCIONES MATEMTICAS
abs versin real
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,
_fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min, poly, pow10, random, randomize, _rotl, _rotr, _status87.
versin compleja
int abs (int x); double abs(complex x);
#include <math.h> #include <stdlib.h> #include <complex.h>
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
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.
Clase complex
acos
#include <math.h> #include <complex.h>
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; }
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); // el ngulo devuelto es /3
// 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:

struct complex z = {1.5,1.5} // z = 1.5 + i1.5;
arg double arg(complex x);
#include <complex.h>
653
La funcin arg() devuelve el ngulo, en radianes, de un nmero en el plano complejo.

complex z; double angulo; z = complex(1.5, 4.5); angulo = arg(z);
Calcula el arco tangente de y/x. El resultado es un ngulo de valor comprendido entre y radianes.
angulo = atan2(y, x);
Funciones relacionadas: atan, matherr, tan.

cabs double babs(struct complex z); #include <math.h>
Funciones relacionadas: complex, norm, polar.
asin versin real
versin compleja
double asin(double x);
Calcula el valor absoluto de un nmero complejo almacenado en una estructura de tipo complex.
struct complex z; double complejo; z.y = 3.5 z.y = 2.4 complejo = cabs(z); printf(valor absoluto %lf\n, complejo);
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.
Z = asin(0.7543);
Funciones relacionadas: fabs, hypot, matherr, sqrt. Funciones relacionadas: matherr, sin.
ceil atan versin real #include <math.h>
versin compleja
double atan(double x);
double ceil (double x);
Calcula (redondea) el nmero entero mayor que o igual a x.

redondeo = ceil(5.1) // redondeo es 6
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.
#include <complex.h> complex atan(complex x); angulo = atan(1.0); // ngulo es Pi/4 (45 grados)
Funciones relacionadas: floor.
_clear87 unsigned int _clear87(void);
#include <float.h>
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>
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;
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.
estado = control87(PC24,MCW_IC); // precisin 24 bits
// cociente // resto
div_t resultado; resultado = div(35, 8); // resultado.cociente = 4, resultado.resto = 3
Funciones relacionadas: _clear87, _status87.

exp cos double cos(double x); complex cos(complex x); #include <math.h> double exp(double x); complex exp(complex x); #include <amth.h> #include <complex.h>
Calcula el coseno del argumento x. El argumento x se especifica en radianes y devuelve un valor en el rango de 1 a 1.
coseno_x = cos(1.6543);
Calcula el exponencial de x:ex; donde e es la base del logaritmo natural (e = 2.7182818).

x = 100.00; y = exp(x); printf(El exponencial de x = %f.\n,y);
Funciones relacionadas: acos, sin.

cosh double cosh(double x); complex cosh(complex x); #include <math.h>
Funciones relacionadas: log, pow.
fabs, fabsl double fabs(double x); long double fabs(long double x);
#include <math.h>
Calcula el coseno hiperblico de la variable x. Si el argumento pasado a cosh() es demasiado grande, se produce un error de rango.
x = 1.00 printf(x = %f.\n\n,x); y = cosh(x); printf(coseno hiperblico x = %f.\n\n, y);
Calcula el valor absoluto de un nmero en coma flotante x.

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

div div_t div(int x, int y); #include <stdlib.h>
Funciones relacionadas: cabs.
floor double floor(double x);
#include <math.h>
655
Redondea por defecto el valor de x.

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

resto = (fmod(5.0, 2.0); // resto igual a 1.0
Calcula la hipotenusa de un tringulo rectngulo cuyos lados son x e y. Una llamada a hypot equivale a lo siguiente:
sqrt(x * x, y * y);
Funciones relacionadas: floor.

double x = 3.0; y = 4.0; printf(%lf, hypot(x, y)); _fpreset void _fpreset(void); #include <float.h> imag double imag(complex x); #include <complex.h>
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
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 relacionadas: _control87, signal.
Funciones imaginarias: complex, conj, real.

frexp(), frexpl() double frexp(double x, int *exp); long double frexpl(long double x, int *exp); #include <math.h> labs long int labs(long int n); #include <math.h>
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.
Calcula el valor absoluto de un entero largo (n).

long lx = 51654L, ly; ly = labs(lx);
Funciones relacionadas: abs, cabs, fabs.
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.

_lrotl #include <stdlib.h>
Funciones relacionadas: frexp, modf.

unsigned long _lrotl(unsigned long x, int c);
ldiv ldiv_t ldiv(long int x, long int y);
#inxlude <stdlib.h>
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.
typedef struct { long quot; long rem; } ldiv_t; long x = 5258625, y = 341654; ldiv_t resultado; resultado = ldiv(x, y); printf(el cociente y el resto es %ld, %ld,\n, resultado.quot, resultado.rem);
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.
unsigned long x = 0x0fac45491; printf(x desplazado 4 veces es, _lrotl (x, 4);
Funciones relacionadas: _lrotr, _rotl, _rotv.

_lrotr #include <stdlib.h>
unsigned long _lrotr(unsigned long x, int c);
Funciones relacionadas: div.
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
Funciones relacionadas: _lrotl, _rotl, _rotr.

matherr _matherrl int matherr(struct exception *e); int _matherrl(struct _exception1 *e)
double log(double x); double log10(double x);
#include <math.h>
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
657
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.
max (tipo) max(a, b); #include <conio.h>
polar
#include <complex.h>
complex polar(double modulo, double angulo);
Devuelve un nmero complejo con una magnitud (mdulo) y ngulo dado.

complex < = complex(x, y); polar(mag, ang)es lo mismo que complex(mag*cos(ang), mag *sin(ang);
Devuelve el mayor de dos valores. Ambos argumentos y la declaracin de la funcin deben ser del mismo tipo.
double dbl1, dbl2, dblmax; dblmax = max(dbl1, dbl2);
Funciones relacionadas: Slo existe en C+.

poly #include <math.h>
Funciones relacionadas: min.

min (tipo) min(a, b); #include <stdlib.h>
double poly(double x, int n, double c[]);
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]
// polinomio: 3x**2 + 2x + 1// double c[] = {-10.0,2,c);
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);
Funciones relacionadas: pow.

rand
Funciones relacionadas: max.

#include <stdlib.h> modf, modfl #include <math.h>
int rand(void);
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.
pardecimal = modf(36.95, &parte_entera(; // parte entera 36, parte decimal .95
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.
// visualizar 10 nmeros aleatorios // for(i = 0; 1 < 10; i++) printf(%6d\, rand());
Funciones relacionadas: frexp,ldexp.
Funciones relacionadas: random, randomize, srand.
658
random
#include <stdlib.h>
Rota el valor de x,c bits a la izquierda.

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: _lrotl, _rotr, _rotr.

_rotr unsigned _rotr(unsigned x, int c); #include <stdlib.h>
Funciones relacionadas: rand, randomize.

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

sin #include <math.h> #include <complex.h>
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.
randomize();
double sin(double x); complex sin(complex x);
Funciones relacionadas: rand, random, srand.

real #include <complex.h> #include <bcdh.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);
double real(complex x); double real(bcd x);
Funciones relacionadas: asin, cos, sinh.

sinh #include <math.h> #include <complex.h>
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++.

_rotl unsigned _ rotl(unsigned x, int c); #include <stdlib.h>
double sinh(double x); complex sinh(complex x);
Devuelve el seno hiperblico de x (x, se supone en radianes).

y = sinh(x);
Funciones relacionadas: sin, cosh.
659
sqrt double sqrt(double x); complex sqrt(complex x);
#include <math.h>
tanh
double tanh(double x); complex tanh(complex x); // se visualiza 5
Calcula la raz cuadrada de un nmero x no negativo.

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

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

srand 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#include <stdlib.h>
Funciones relacionadas: cosh, tanh.
F.13.
FUNCIONES DE MANIPULACIN DE BLOQUES DE MEMORIA (BUFFERS)
dor a un punto inicial aleatorio.

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

_status87 unsigned int _status87(void); #include <float.h>
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.
Obtiene el contenido de la palabra de estado de coma flotante.

estado = _status87();
memccpy
#include <mem.h> #include <string.h>
void *memccpy(void *dest, const void *s, int c, size_t n);
Funciones relacionadas: _clear87, _control87. Copia n bytes desde s a dest hasta que n bytes han sido copiados o c se copia a dest.
tan #include <math.h> #include <complex.h> res = memccpy(buf_dest, bufen, c, 81);
double tan(double x); complex tan(complex x);
Funciones relacionadas: memcpy, memmove, movedata, movmem.
Calcula la tangente de x (x, se supone en radianes).

y = tan(x)
memchr
#include <mem.h> #include <string.h>
Funciones relacionadas: atan.
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);
memmove
#include <string.h> #include <mem.h>
void
*memmove(void *dest, const void *f, size_t n);
Funciones relacionadas: memcmp, memicmp.

memcmp #include <mem.h>
Mueve n bytes de un buffer (f) a otro (dest). Funciones relacionadas: memccpy, memcpy, movedata.
memset #include <string.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:
< 0 si b1 < b2 = 0 si b1 = b2 > 0 si b1 > b2 resultado = memcmp(buf1, buf2, sizeof(buf1));
void *memset(void *s, int c, size_t n);
Fija los n primeros bytes del array s al carcter c.

resultado = memset(buffer,1, 50);
Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.

movedata #include <mem.h> #include <string.h>
Funciones relacionadas: memicmp.

memcpy #include void movedata (unsigned ss, unsigned so, unsigned ds, unsigned do, size_t n);
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):
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: memccpy, memmove, movedata.

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

movmem #include <mem.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.
if(memicmp(buf1, buf2, 15) == 0) puts(Los buffers son iguales en los 15 primeros bytes \n);
void movmem(void *fuente, void *destino, unsigned n);
Copia n bytes de fuente a destino.

movmem(&fuente[6], fuente, sizeof(fuente));
Funciones relacionadas: memcmp.
Funciones relacionadas: memmove.
661
setmem
#include <mem.h>
clrscr void (clrscr(void);
#include <conio.h>
void setmem(void *dest, unsigned long, char c);
Fija un bloque de long bytes en el buffer dest al carcter c. setmem es til para inicializar buffers.
setmem(buffer, 60, t);
Borra la ventana actual y pone el cursor en la esquina superior izquierda (1,1).

clrscr();
Funciones relacionadas: memset.

swab #include <stdlib.h>
Funciones relacionadas: clreol, textbackground, window.

delline void delline(void); #include <conio.h>
void swab(char *fuente, char *destino, int n);
Copia un nmero par de bytes de una posicin a otra, intercambiando al mismo tiempo cada par de bytes adyacentes.
swab(mnpq, resultado, 4); // resultado es nmpq
Borra la lnea completa que contiene el cursor y desplaza hacia arriba las lneas que haya debajo.
delline();
Funciones relacionadas: clreol, clrscr. Funciones relacionadas: Slo est disponible en sistemas UNIX.
gettext #include <conio.h>
F.14.
FUNCIONES DE PRESENTACIN DE TEXTO
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.
clreol void clreol(void); #include <conio.h>
int gettext(int izda, int arriba, int derecha, int abajo, void *textbuf);
Copia el contenido de un rea rectangular de la pantalla al buffer cuya direccin se da en el argumento textbuf. Todas las coordenadas son absolutas.
if(!gettext(1,1,30,20, pan_grabada)) puts(color);
Funciones relacionadas: movetext, puttext.

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.

struct text_info { unsigned char winleft; 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
Inserta una lnea en blanco en la ventana de texto actual en la posicin del cursor, desplazando el resto de las lneas situadas debajo.
insline();
Funciones relacionadas: clreol, delline, window.
lowvideo void lowvideo(void);
#include <conio.h>
Activa los caracteres a baja intensidad.

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

#include <conio.h> movetext #include <conio.h>
gotoxy void gotoxy(int x, int y);
Mueve el cursor a una posicin especificada (columna x, fila y) dentro de la ventana de texto actual.
gotoxy(15, 4);
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.
if (!movetext(1, 1, 30, 20, 40, 40)) puts(victoria);
Funciones relacionadas: wherex, wherey, window.
highvideo void highvideo(void);
#include <conio.h>
Funciones relacionadas: gettext, puttext.
Activa caracteres de alta intensidad.

highvideo();
normvideo void normvideo(void);
#include <conio.h>
Funciones relacionadas: lowvideo, normvideo, textcolor.
Reinicializa los atributos de texto al valor que tenan antes de que arranque el programa.
normvideo();
insline void insline(void);
#include <conio.h>
Funciones relacionadas: highvideo, lowvideo, textattr, textcolor.
663
puttext
#include <conio.h>
textbackground void textbackground(int colorfondo);
#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.

puttext(3, 1, 32, 22, buffertexto);
Establece el color de fondo para texto vidualizado.

textbackground(2);
Funciones relacionadas: gettext, movetext.
textcolor void textcolor(int colorprimerplano);
#include <conio.h>
_setcursortype void setcursortype(int estilo_cursor);
#include <conio.h>
Establece el color del primer plano del texto visualizado por cprintf y cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15 WHITE (blanco).
textcolor(15);t
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.
Funciones relacionadas: textattr, textbackground.
setcursortype(_SOLIDCURSOR);
texmode void textmode(int nuevomodo);
#include <conio.h>
Funciones relacionadas: cprintf, cputs.
Conmuta al modo texto especificado por el argumento nuevomodo.

textattr void textattr(int atrib); #include <conio.h> -1 0 1 2 3 7 64 LASTMODE BW40 C40 BW80 C80 MONO C4350
Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia del texto en la pantalla.
textattr(YELLOW + (RED << 4)); textattr(10110100);
ltimo modo de texto. Monocromo 40 columnas. Color 40 columnas. Monocromo 80 columnas. Color 80 columnas. Monocromo 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);
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)
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);
Funciones relacionadas: gettextinfo, textmode.

Bibliotecas Borland y C++F

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Bibliotecas Borland y C++F

Caricato da

Copyright:

Formati disponibili

APNDICE F

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

FUNCIONES DE ASIGNACIN DE MEMORIA

nombre funcin strrev

PLANTILLA REFERENCIA DE ENTRADAS

PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Funciones relacionadas: free, farmalloc, malloc, sbrk.

int *calloc(size_t n, size_t s);

Funciones relacionadas free, malloc.

int allocmen(unsigned t, unsigned * seg);

Funciones relacionadas: calloc, farcoreleft, malloc.

Funciones relacionadas: falloc frremem, malloc, setblock.

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

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

Funciones relacionadas: calloc, farfree, farmalloc, malloc.

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

Determina el nmero total de bytes disponibles en el sistema.

Funciones relacionadas: coreleft, farcalloc, farmalloc.

farheapfillfree int farheapfillfree(unsigned int f);

Libera la memoria apuntada por b.

Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk.

Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.

farheapwalk int farheapwalk(struct farheapinfo *m);

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

Verifica la consistencia del montculo (heap) far.

farmalloc void far *farmalloc(unsigned long n);

Funciones relacionadas: farheapcheckfree, farheapchecknode, farheapwalk, heapfillfree, heapwalk, heapcheck.

farheapcheckfree int farheapcheckfree(unsigned int f);

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

Funciones relacionadas: calloc, farfree, farcalloc, malloc.

PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

heapcheckfree int heapcheckfree(unsigned int f);

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

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

Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

vid free(void *dir_memoria);

Funciones relacionadas: farheapchecknode, heapcheck, heapcheckfree, heapfillfree, heapwalk.

heapfillfree int heapfillfree(unsigned int f);

Funciones relacionadas: calloc, malloc, realloc

heapcheck int heapcheck(void);

Funciones relacionadas: farheapfillfree, heapcheck, heapcheckfree, heapwalk.

heapwalk int heapwalk(struct heapinfo *i);

Funciones relacionadas: heapcheckfree, heapchecknode, heapfillfree, heapwalk, farheapcheck.

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

struct heapinfo i; estadoheap = heapwalk(&i);

Funciones relacionadas: farheapwalk, heapcheck.

setblock(unsigned seg, unsigned n);

Ajusta el tamao de un bloque de memoria asignado anteriormente por

void *malloc (size_t n);

FUNCIONES DE BSQUEDA Y ORDENACIN

Funciones relacionadas: calloc, free, realloc.

*realloc(void *b, size_t n);

Funciones relacionadas: calloc, free, malloc.

sbrk void *sbrk(int n);

Funciones relacionadas: brk, coreleft

PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS

Valor devuelto Negativo Cero Positivo

Ordenar la lista de enteros y visualizar el resultado.

Funciones relacionadas: bsearch, lsearch, qsort.

Funciones relacionadas: bsearch, lfind, lsearch.

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

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

realloc(void b, size_t n);

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

strchr char strchr(const char cad, int c);

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

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

size_strcspn(const char cad1, const char cad2);

strlwr char strlwr(char cad);

char strerror(const char cad);

it stricmp(const char cad1, const char cad2);

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

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

char strnset(char cad, int c, size_t n);

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

strset char strset(char cad, int c);

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

sze_t strspn(const char cad1, constchar cad2);

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

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

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

strupr char strupr(char cad);