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

F.1. PlahIilla reIerehcia de ehIradas.
F.2. Fuhciohes de asighacih de memoria.

F.3. Fuhciohes de busqueda y ordehacih.
F.4. Fuhciohes de cadeha.
F.5. Fuhciohes de clasiIicacih de caracIeres.
F.6. Fuhciohes de calehdario (Iecha y hora).
F.7. Fuhciohes de cohIrol de direcIorios.
F.8. Fuhciohes de cohIrol de procesos.
F.9. Fuhciohes de cohversih de daIos.
F.10. Fuhciohes de ehIrada/salida.
F.11. Fuhciohes de gesIih de archivos.
F.12. Fuhciohes maIemaIicas.
F.13. Fuhciohes de mahipulacih de bloques de memoria (buIIers).
F.14. Fuhciohes de presehIacih de IexIo.
A P N D I C E F
B I B L I O T E C A D E F U N C I O N E S E S T N D A R
A N S I ] I S O C + + Y B O R L A N D C + + 5 . 0
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 ejecu-
cin 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 archi-
vos, asignacin de memoria, control de procesos, clculos matemticos, etc.
Las rutinas de Borland C++ estn contenidas en los archivos de bibliote-
ca Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ imple-
menta la versin estndar ltima de ANSI C, que entre otras cosas recomien-
da el uso de los prototipos de funcin en las rutinas de sus programas C++.
Este apndice describe alfabeticamente funciones de la biblioteca Bor-
land C++ y contiene todas las funciones incluidas en ANSI/ISO C++.
F.1. PLANTILLA REFERENCIA DE ENTRADAS
Las entradas de las diferentes funciones y macros han sido normalizadas
para facilidad de manejo del lector. Las rutinas han sido clasificadas por
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 des-
cripcin o propsito. A continuacin, por orden alfabtico, se describen las
rutinas de acuerdo al siguiente modelo para cada entrada.
F.2. FUNCIONES DE ASIGNACIN DE MEMORIA
Borland C++ almacena informacin en la memoria principal de la compu-
tadora 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 informa-
cin 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
CONTENDO
nombre funcin archivo de cabecera
strrev #include <string.h>
char *strrev(char *cad) sintaxis
Descripcin
Propsito y breve descripcin de cmo y dnde se utiliza la funcin.
Ejemplo
Una o ms instrucciones o programas sencillos, donde se muestra la explicacin
real de la funcin.
Funciones relacionadas: strcpy, strncpy.
Funciones relacionadas con la funcin descrita.
memoria para colas diferentes en un tiempo distinto. Este proceso de asig-
nar 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 cdi-
go 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 argu-
mentos) y montn o montculo heap.
Segmento de datos
Despus de asignar partes del segmento de datos a variables estticas y
globales y a la pila, el compilador dedica el resto del segmento de datos al
montculo o heap.
Borland C++ contiene un gran nmero de funciones para asignacin
dinmica de memoria, que realizan una gran variedad de tareas: asignar y
liberar memoria del montculo y de la pila, obtener informacin de bloques
de memoria, etc.
allocmen #include <dos.h>
int allocmen(unsigned t, unsigned * seg);
La funcin allocmen() establece seg para apuntar a un segmento asig-
nado 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);
Funciones relacionadas: falloc frremem, malloc, setblock.
brk #include <alloc.h>
int brk( void* a)
La funcin brk permite modificar el valor break de un programa. El
valor break es la direccin de la primera posicin ms all del segmento de
Montculo Pila Datos del programa
(heap) (stack)
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);
Asigna memoria principal (un bloque de tamao n.s). El bloque se
borra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debe
utilizar farcalloc. Devuelve un puntero al bloque recin asignado. Si no
existe bastante espacio para el nuevo bloque o bien n o s es 0, calloc
devuelve nulo.
long *buffer
buffer=(long *) calloc(40, sizeof(long));
Funciones relacionadas free, malloc.
coreleft #include <alloc.h>
unsigned coreleft(void) // modelos small, tiny, medium
unsigned long coreleft(void); // en otros modelos de memoria
Determina la cantidad de memoria no utilizada. El valor devuelto
depende del modelo de memoria.
Mem_avail = coreleft();
Funciones relacionadas: calloc, farcoreleft, malloc.
farcalloc #include <alloc.h>
void far *farcalloc(unsigned long n, unsigned long s);
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.
616 PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
if(array_grande=farcalloc(20000L, sizeof (int)) NULL)
printf (Fallo en asignacin de memoria\n);
Funciones relacionadas: calloc, farfree, farmalloc, malloc.
farcoreleft #include <alloc.h>
unsigned long farcoreleft(void);
Determina el nmero total de bytes disponibles en el sistema.
memoria_total_disponible = farcoreleft();
Funciones relacionadas: coreleft, farcalloc, farmalloc.
farfree #include <alloc.h>
void farfree(void far *b);
Libera la memoria apuntada por b.
farfree(arraygrande);
Funciones relacionadas: farcalloc, farmalloc, farrealloc, free.
farheapcheck #include <alloc.h>
int farheapcheck(void);
Verifica la consistencia del montculo (heap) far.
estadoheap = farheapcheck();
Funciones relacionadas: farheapcheckfree, farheapchecknode,
farheapwalk, heapfillfree, heapwalk, heapcheck.
farheapcheckfree #include <alloc.h>
int farheapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montculo (heap) far.
estadoheap = farheapcheckfree(F);
Funciones relacionadas: farheapfillfree, farheapwalk, heapfill-
free, heapcheckfree, heapwalk.
farheapchecknode #include <alloc.h>
int farheapchecknode(void *bloque);
Verifica la consistencia de un solo bloque en el montculo (heap) far.
estadoheap = farheapchecknode(arraygrande);
farheapfillfree #include <alloc.h>
int farheapfillfree(unsigned int f);
Rellena todos los bloques libres del montculo far con un valor constante.
estadoheap = farheapfillfree(X);
Funciones relacionadas: farheapcheckfree, farheapchecknode,
farheapwalk, heapfillfree, heapwalk.
farheapwalk #include <alloc.h>
int farheapwalk(struct farheapinfo *m);
Obtiene informacin sobre las entradas en el montculo (heap) far.
struct farheapinfo heap_entry;
estadopila = farheapwalk(&heap_entry);
farmalloc #include <alloc.h>
void far *farmalloc(unsigned long n);
Asigna n bytes de memoria far. La cantidad completa de memoria
encima de la pila est disponible para asignacin por farmalloc. El tamao
del bloque puede exceder de 64 Kb.
if(bloquegrande = farmalloc(80000L) == NULL
printf(Asignacin fallada\n);
Funciones relacionadas: calloc, farfree, farcalloc, malloc.
BIBLIOTECA DE FUNCIONES ESTNDAR ANSI]ISO C++ Y BORLAND C++ 5.0 617
farrealloc #include <alloc.h>
void far *farrealloc(void far *b, unsigned long n)
Se utiliza para reasignar (ajustar el tamao de un bloque de memoria b,
al cual se ha asignado una longitud de n bytes).
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL
printf(Fallo reasignacin memoria\n);
Funciones relacionadas: calloc, farcalloc, farfree, malloc.
free #include<alloc.h>
#include <stdlib.h>
vid free(void *dir_memoria);
La funcin free() libera un bloque de memoria. El argumento
dir_memoria apunta a un bloque de memoria previamente asignado a
travs de una llamada a calloc, malloc o realloc. Despus de la llama-
da el bloque libre est disponible para asignacin.
char *cad;
// asignar memoria para cadena
cad = (char *) malloc(50);
...
free(cad); // liberar memoria
Funciones relacionadas: calloc, malloc, realloc
heapcheck #include <alloc.h>
int heapcheck(void);
Verifica la consistencia del montculo (heap). En Visual C++ 6.0 la fun-
cin equivalente es _heapcheck();
estadoheap = heapcheck();
Funciones relacionadas: heapcheckfree, heapchecknode, heapfill-
free, heapwalk, farheapcheck.
heapcheckfree #include <alloc.h>
int heapcheckfree(unsigned int f);
Verifica la consistencia de los bloques libres en el montculo (heap).
estadoheap = heapcheckfree(N);
Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.
heapchecknode #include <alloc.h>
int heapchecknode(void *n);
Verifica la consistencia de un solo nodo (bloque de memoria). Verifica
el bloque de memoria identificado por el puntero n.
estadopila = heapchecknode(array);
Funciones relacionadas: farheapchecknode, heapcheck, heapcheck-
free, heapfillfree, heapwalk.
heapfillfree #include <alloc.h>
int heapfillfree(unsigned int f);
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);
Funciones relacionadas: farheapfillfree, heapcheck, heapcheck-
free, heapwalk.
heapwalk #include <alloc.h>
int heapwalk(struct heapinfo *i);
Se utiliza para obtener informacin sobre las entradas en el montculo
(heap). La funcin equivalente en Visual C++ es _heapwalk.
struct heapinfo i;
estadoheap = heapwalk(&i);
Funciones relacionadas: farheapwalk, heapcheck.
malloc #include <stdlib.h>
#include <alloc.h>
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)
Funciones relacionadas: calloc, free, realloc.
realloc #include <alloc.h>
#include <stdlib.h>
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.
sbrk #include <alloc.h>
void *sbrk(int n);
Se utiliza sbrk para indicar el valor break de un proceso. El valor
break es la direccin del primer byte disponible en el segmento de datos por
omisin, ms all del segmento de datos que est siendo utilizado por los
datos en el proceso.
sbr(500);
Funciones relacionadas: brk, coreleft
setblock #include <alloc.h>
int 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.
F.3. FUNCIONES DE BSOUEDA Y ORDENACIN
La mayora de los programas requieren casi siempre alguna operacin de
clasificacin y bsqueda de elementos en arrays. Borland C++ incluye dife-
rentes funciones que realizan estas tareas.
bsearch() #include <stdlib.h>
void bsearch(const void*k, const void *b, size_t n, size_t a,
int(*comparar)(const void*, const void*));
La funcin bsearch realiza una bsqueda binaria en un array ordena-
do b, de n elementos, cada uno de a bytes de tamao. El argumento k apun-
ta 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 elemen-
to del array. La funcin comparar compara cada uno de los elementos apun-
tados y devuelve un valor de acuerdo con la tabla siguiente:
Valor devuelto Condicin
Negativo Primer elemento menor que el segundo (elem1) (elem2).
Cero Los dos elementos son idnticos.
Positivo Primer elemento mayor que el segundo.
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.
lfind #include <stdlib.h>
void * lfind(const void k, const void *b, size_t *num, size_t
anchura, int(*comparar)(const void*, const void*));
La funcin lfind() realiza una bsqueda lineal de valor de k (clave) en
un array de un nmero especfico de elementos, cada uno de un nmero fijo
de bytes de longitud. Al contrario que bsearch(), el array no necesita
estar ordenado. lfind() devuelve un puntero al primer elemento del array
que coincide con la clave; si la clave no existe en el array, se devuelve un 0.
int comp(const void*, const void *); resultado = (char **)
lfind(palabrabuscada, envp, &cuenta, sizeof(char*), comp);
Funciones relacionadas: bsearch, lsearch, qsort.
lsearch #include <stdlib.h>
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 uti-
liza 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>
void qsort(void a, size_t n, size_t w, int(*comparar) (const void*,
const void*));
La funcin qsort ordena un array con un nmero dado de elementos
utilizando el mtodo de ordenacin rpida quicksort (creado por C.A.R.
Hoare). El nmero de elementos de array es n y el tamao (en bytes) de cada
elemento es w. La funcin comparar se utiliza para comparar un elemento
del array con la clave; devuelve los siguientes valores:
Valor devuelto Condicin
Negativo Primer elemento (elem1) menor que el segundo (elem2).
Cero Los dos elementos son idnticos.
Positivo Primer elemento mayor que el segundo.
Ordenar la lista de enteros y visualizar el resultado.
#include <stdlib.h>
#include <stdio.h>
int comparar(const void*, const void *);
int numeros[10] = {4,5,7,3,12,8,6,1,0,2};
main(void)
{
int i;
printf(lista original:);
for(i =0; i < 10; i++)
printf(%d, numeros[i]);
qsort(numeros,10,sizeof(int), comparar);
printf(lista ordenada:);
for(i = 0; i < 10; i++)
printf(%10, numeros[i]);
return 0;
}
// comparar enteros
comparar(const void *i, const void *j)
{
return ((int *)i) ((int *) j)
}
Funciones relacionadas: bsearch, lfind, lsearch.
F.4. FUNCIONES DE CADENA
C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan
como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notacin
el final de una cadena en C se representa por un byte que contiene un carcter
nulo (\0). Las cadenas pueden ser declaradas como arrays de caracteres.
char cad[20], cad 5[] = Hola Mortimer;
Acceso a Ias cadenas
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;
Se puede tambin declarar e inicializar una cadena a la vez:
char *p_cad5 = Hola Mortimer;
El archivo de cabecera <string.h> contiene numerosas funciones que
manipulan cadenas.
stpcpy #include <string.h>
char *stpcpy(char *cad1, const char *cad2);
La funcin stpcpy() copia una cadena en otra. Devuelve un puntero al
final de la cadena copiada. Se devuelve el valor de cad1+strlen(cad2)
stpcpy(orden_dos, DIR);
stpcpy(caad1, cad2);
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 cade-
na resultante con un carcter nulo (\0).
char nombre[80] = Bob;
char blanco[2] = ;
char ultimo[80] = Marley;
...
strcat(nombre,blanco); // blanco se concatena a nombre
strcat(nombre,ultimo); // ultimo se concatena a nombre
// la cadena nombre ser Bob Marley
Funciones relacionadas: strcpy, strdup, strncat, strncpy.
strchr #include <string.h>
char *strchr(const char *cad, int c);
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, $));
visualizar $85725
char *s[81] = Esta es una cadena de prueba;
char *ptr;
ptr = strchr(s, a);
el valor almacenado en ptr es un puntero a la primera aparicin de a.
strcmp #include <string.h>
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); // resultado < 0
i = strcmp(abc, abc); // resultado = 0
i = strcmp(xy, abc); // resultado > 0
char s1[80] Mayo;
char s2[80] = Octubre;
int j;
j = strcmp(s1, s2);
Funciones relacionadas: strcmpi, stricmp, strnicmp, strncmp.
strcmpi #include <string.h>
int strcmpi(const char *cad1, const char * call2);
Compara una cadena con otra sin diferenciar entre maysculas y mins-
culas y devuelve un entero:
< 0 si cad1 < cad2
= 0 si cad1 = cad2
> 0 si cad1 > cad2
v = strcmpi(c1, c2);
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.
strcoll #include <string.h>
int strcoll(const char *cad1, const char cad2);
Compara cad1 con cad2. Devuelve un valor.
< 0 si cad1 < cad2
= 0 si cad1 = cad2
> 0 si cad1 > cad2
if(strcoll(nombre1, nombre2)! = 0)
exit(EXIT_FAILURE);
Funciones relacionadas: setlocate, strcmp, strcmpi, strncmp,
strxfrm.
strcpy() #include <string.h>
char *strcpy(char *cad1, const char *cad2);
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;
Funciones relacionadas: strcat, strcup, strncat, strncpy.
strcspn #include <string.h>
size_strcspn(const char *cad1, const char *cad2);
Localiza la posicin de la primera aparicin en una cadena de cualquier
carcter de otra cadena. Si tiene xito, la funcin strcspn devuelve el ndi-
ce del primer carcter de cad1, que pertenece al conjunto de caracteres de
cad2.
primero = strcspn(circunloquio, q);
// primero = 8
Funciones relacionadas: strpbrk, strspn.
strdup #include <string.h>
char * strdup(const char *cad);
Asigna memoria y copia una cadena dada en ese espacio. En realidad,
strdup() llama a malloc para asignar suficiente memoria para contener a
cad. Si falla la asignacin de memoria, strdup() devuelve un carcter nulo
(NULL).
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;
}
strerror #include <string.h>
char *strerror(int errnum);
Obtiene el mensaje de error del sistema correspondiente al nmero dado
en el argumento errnum. La funcin strerror() obtiene el mensaje de
error del sistema utilizando el valor en la variable global errno, como el
ndice una tabla de errores denominadas sys_errlist, que est declarado
en el archivo de cabecera stdlib.h.
errno = 0;
printf (Error, strerror(errno);
Funciones relacionadas: perror, _strerror.
strerror #include <string.h>
#include stdio.h
char *strerror(const char *cad);
Esta funcin sirve para generar un mensaje de error definido por el
usuario.
printf(%S, _strerror(error apertura archivo));
Funciones relacionadas: perror, strerror.
stricmp #include <string.h>
it stricmp(const char *cad1, const char *cad2);
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 res-
pecto a cad2.
Si cad1 = cad2 el valor de la funcin es cero.
Si cad1 < cad2 el valor de la funcin es menor que cero.
Si cad1 > cad2 el valor de la funcin es mayor que cero.
Resultado = stricmp(cad1, cad2),
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.
strlen #include <strign.h>
size_t strlen(const char *cad);
Proporciona la longitud de una cadena cad. El carcter nulo no se inclu-
ye en la longitud; en consecuencia, cuando reserve espacio, recuerde aadir
1 al valor devuelto por strlen.
longitud = strlen(nombre);
char s[81] = Cadena demo;
printf(La longitud de s es:%d\n strlen(s));
Funciones relacionadas: _fstrlen.
strlwr #include <string.h>
char *strlwr(char *cad);
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: strupr, toloweer.
strncat #include <string.h>
char *strncat(char *cad1, const char *cad2, size_t n);
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;
Funciones relacionadas: strcat, strdup, strcpy, strncpy.
strncmp #include <string.h>
int strncmp(const char *cad1, const char *cad2, size_t n);
Compara un nmero especificado en caracteres de dos cadenas y
devuelve un entero con un valor.
< 0 si cad1 < cad2
= 0 si cad1 < cad2
> 0 si cad1 < cad2
char *a = Mortimer el andaluz;
char *b = Mortimer el mexicano;
if((strncmp(a, b, 8)) == 0)
cout << Ambas cadenas comienzan con \Mortimer\;
else
cout << Estas cadenas no comienzan con \Mortimer\;
Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, str-
nicmp.
strnset #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 carac-
teres que se han de inicializar.
gets(cadena);
printf(Introducir un carcter:);
c = getche();
long = strlen(cadena)/2;
strnset(cadena, c, lon);
Funciones relacionadas: memset, setmem, strset.
strpbrk #include <string.h>
char *strpbrk(const char *cad1, const char *cad2);
Encuentra la primera aparicin en cad1 de cualquiera de los caracteres
de cad2. El carcter nulo no se incluye en la bsqueda. Si el carcter no
existe, se devuelve un carcter nulo (NULL).
char *s = Mortimer L.J. Mackoy;
char *p = strpbrk(s, L4);
cout << p << \n; // la salida es L.J.Mackoy
Funciones relacionadas: strchr, strcspn.
strrchr #include <string.h>
char *strrchr(const char *cad, int c);
Encuentra la ltima aparicin del carcter c en cad. Devuelve un pun-
teo 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: strchr.
strrev #include <string.h>
char *strrev(char *cad);
Invierte los caracteres de la cadena cad. El carcter de terminacin nulo
permanece en el mismo lugar. strrev() devuelve un puntero a la cadena
inversa.
Aplicacin: Invertir una cadena leda del teclado e imprimir el resultado.
#include <stdio.h>
#include <string.h>
main()
{
char demo[80]
gets(demo);
strrev(demo);
printf(La cadena inversa es:\n %s |\n, demo);
return 0;
}
Funciones relacionadas: strcpy, strncpy.
strset #include <string.h>
char *strset(char *cad, int c);
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 cade-
na modificada.
char *cad = -----;
strset (cad, x); // cad es ahora xxxxx
Funciones relacionadas: strnset.
strspn #include <string.h>
sze_t strspn(const char *cad1, constchar *cad2);
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: strcmp, strcspn.
strstr #include <string.h>
char *strstr(const char *cad1, const char *cad2);
Localiza la primera aparicin de una cadena en otra. Si tiene xito, la
funcin strstr devuelve un puntero a la primera aparicin de cad2 como
una subcadena de cad1. Si la bsqueda falla, se devuelve NULL.
char *s = Mi autor favorito es Octavio Paz
char *a = Octavio Paz;
cout << La subcadena << a << se encuentra:
<< strstr(s, a) << \n;
Funciones relacionadas: strchr, strcspn, strpbrk
strtok #include <string.h>
char *strtok(char *cad1, const char *cad2);
Rompe una cadena en subcadenas (token) utilizando una lista de sepa-
radores. Devuelve un puntero a la subcadena actual y un NULL cuando se
alcanza el final de la cadena.
char *s = Prefiere a Verdi, o a Pucini?;
char *t = .,!* ;
cout << strtok(s, t) << \n;
cout << strtok(NULL, !);
Funciones relacionadas: strpbrk, strcspn.
strupr #include <string.h>
char *strupr(char *cad);
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 biblio-
teca ANSI C. En estos casos, utilice las funciones toupper y tolower.
strupr(sierra madre); // SIERRA MADRE
Funciones relacionadas: strlwr, toupper.
strxfrm #include <string.h>
size_t strxfrm(char *cad1, char *cad2, size_t n);
Convierte cad2 en cad1 basado en informacin especfica local y con
un nmero mximo de caracteres a situar en cad1 de n. En el siguiente
ejemplo, strxfrm transforma los tres primeros caracteres de cad1 en los
tres primeros caracteres de cad2.
char *cad1 = abcdefg;
char *cad2 = 1234567;
clrscr();
strxfrm(cad1, cad2, 3);
printf(Transformada: %s\n, cad1);
F.5. FUNCIONES DE CLASIFICACIN
DE CARACTERES
C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita deter-
minar 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.
Asimismo, existen otras funciones en el archivo ctype.h que sirven
para convertir caracteres en maysculas en minsculas, y viceversa; y valo-
res enteros en cdigos ASCII.
isalnum #include <ctype.h>
int isalnum(int c);
La funcin isalnum() devuelve un cero si c es un carcter no alfa-
numrico y un valor distinto de cero si el carcter es alfanumrico.
carac = getch();
if(isalnum(carac))
printf(%c letra|digito \n, carac);
else
printf(%c no letra|digito \n, carac);
Funciones relacionadas: isascii.
isalpha #include <ctype.h>
int isalpha(int c);
La funcin isalpha() verifica si un carcter es alfabtico. Devuelve un
valor distinto de cero si c es un carcter alfabtico, o 0 si c no es alfabtico.
int c = getah()
if(isalpha) printf(%c es letra\n, c);
Funciones relacionadas: iascii.
isascii #include ctype.h>
int isascii(int c);
Comprueba si un carcter c es un carcter ASCII; c est en el rango 0-127.
Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII.
carac = getch();
if(isascii(carac))
printf(%c es ASCII \n, carac);
else
printf(%c no es ASCII \n, carac);
Funciones relacionadas: toascii, isalnum, isdigit,
iscntrl, isdigit #include <ctype.h>
isgraph, islower
isprint, ispunct, isspace
isupper,isxdigit
int iscntrl(int c);
int isdigit(int c);
int isgraph(int c);
int islower(int c);
int isprint(int c);
int ispunct(int c);
int isspace(int c);
int isupper(int c);
int isxdigit(int c);
Estas macros sirven para determinar propiedades especficas de un
carcter ASCII.
Macro Verifica Rango vlido de valores
iscntrl Carcter de control. 0..1Fh, 7Fh
isdigit Dgito decimal. 0..9
isgraph Carcter imprimible (sin espacio). 21h a 7Eh
islower Carcter minscula. a..z
isprint Carcter imprimible 20h..7Eh
ispunct Carcter puntuacin 21h..2Fh, 3Ah..40h,
5Bh..60h, 7Bh..7Eh
isspace Carcter blanco. 9h..Dh 0 20h (blanco)
isupper Carcter mayscula. A..Z
isxdigit Dgito hexadecimal. 0..9
A..F
a.. f
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)) printf(\n %c imprimible\n, c);
if(iscntrl(c)) printf(%c es un carcter de control\, c);
if(isdigit(c)) printf(%c es un dgito\n, c);
if(islower(c)) printf(%c es letra minscula\n, c)
toascii #include <ctype.h>
int toascii(int c);
Esta funcin convierte un valor entero en un carcter ASCII vlido.
C = toascii(entero);
_tolower
tolower #include <ctype.h>
int _tolower(int c);
int tolower(int c);
Convierte un carcter mayscula en minscula. Utilice _tolower slo
cuando est seguro de que el carcter que quiere convertir es una letra
mayscula.
La funcin _tolower() slo est disponible en sistemas UNIX. Por
consiguiente, para asegurar la compatibilidad utilice slo la funcin tolo-
wer().
c = tolower(S); // c se convierte en S
Funciones relacionadas: iascii, _toupper, toupper.
_toupper
touper #include <ctype.h>
int _toupper(int c);
int _toupper(int c);
int c; // carcter a convertir
Estas funciones convierten un carcter minscula en mayscula. Utili-
ce _toupper slo cuando est seguro de que el carcter que quiere conver-
tir es una letra minscula (rango a-z).
La macro _toupper no est disponible en ANSI C. Para asegurar la
compatibilidad, utilice siempre toupper().
c = toupper(S); // c se convierte en S
Funciones relacionadas: iascii, _tolower, tolower.
F.6. FUNCIONES DE CALENDARIO (FECHA Y HORA)
Las funciones de calendario (fecha y hora) permiten obtener la hora actual
y, a continuacin, convertirla y almacenarla de acuerdo a sus necesidades
particulares. La hora actual se toma siempre de la hora del sistema. Las fun-
ciones de calendario estn incluidas en el archivo de cabecera time.h.
asctime #include <time.h>
char *asctime(const struct tm *hora);
Convierte la fecha y la hora almacenada en una estructura de tipo tm en
una cadena de caracteres. La estructura tm se define en time.h as:
struct tm
{
int tm_sec; // [0,59], segundos
int tm_min; // [0,59], minutos
int tm_hour; // [0,23], horas
int tm_mday; // [1,31], dias del mes
int tm_mon; // [0,11], mes del ao
int tm_year; // [desde 1900], ao
int tm_wday; // [0,6], dias desde domingo
int tm_yday; // [0,265], numero dia ao
int tm_isdst; // indicador hora de verano
};
printf(Fecha/hora es %s\n, asctime(&reloj));
Funciones relacionadas: ctime, gmtime, clocaltime, strftime,
time.
clock #include <time.h>
cock_t clock(void);
Calcula el tiempo empleado por el proceso llamador, es decir, el tiem-
po utilizado de procesador. Devuelve un valor en ticks que ha de dividirse
por la constante CLK_TCK para obtener el tiempo transcurrido en segundos.
clock_t inicio, fin;
printf(Inicio:%f\n, clock()/CLK_TCK;
Funciones relacionadas: gettime, time.
ctime #include <time.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));
Funciones relacionadas: asctime, ftime, strtime, time.
difftime #include <time.h>
double difftime(time_t hora2, time_t hora1);
Obtiene la diferencia entre dos tiempos en segundos.
time_t inicio, fin
clrscrl();
inicio = time(NULL);
delay (5000);
fin = time(NULL);
printf(Diferencia en segundos: %f\n,
difftime(inicio, fin));
Funciones relacionadas: asctime, ctime, gmtime, localtime,
tzset.
dostounix #include <dos.h>
long dostounix(struct date *f, struct time *h);
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en
formato UNIX.
time_t t;
struct time dos_hora;
struct date dos_fecha;
gatdate(&Dos_hora);
gettime(&dos_fecha);
t = dostounix(&dos_fecha, &dos_hora);
Funciones relacionadas: ctime, gatdate, gettime.
ftime #include <sys/timeb.h>
void ftime(struct timeb *ptrhora);
Obtiene la hora actual y la almacena en la estructura timeb apuntada
por ptrhora.
struct timeb {
long time; // segundos desde 00:00:00 hora GMT
short millitm; // milisegundos
short timezone; // diferencia en minutos
// hora Greenwich y hora local
short dstflag; // hora de verano, ahorro de luz
};
ftime(&hora);
Funciones relacionadas: time tzset.
getdate #include <dos.h>
void getdate(struct date *f);
Obtiene la fecha del sistema. Los componentes se almacenan en la
estructura date definida en dos.h.
struct date {
int da_year; // ao actual (1980-2099)
char da_day; // dia mes (1-31)
char da_mon; // mes (1-12)
};
struct date fecha;
getdate(&fecha);
Funciones relacionadas: dostounix, gettime, setdate, settime.
gettime #include <dos.h>
void gettime(struct time *t);
Obtiene la hora actual del sistema. Los componentes de la hora se alma-
cenan en la estructura time definida en dos.h.
struct time {
unsigned char ti_min // minutos (0-59)
unsigned char ti_hour // horas (0-23)
unsigned char ti_hund // centsimas de segundo (0-99)
unsigned char ti_sec // segundos (0-59)
};
struct time hora;
gettime(&hora);
Funciones relacionadas: dostounix, getdate, setdate, settime.
gmtime #include <time.h>
struct tm *gmtime (const time_t *hora);
Convierte la fecha y hora en el tiempo medio de Greenwich (GMT)
(ao, mes, da, hora, minutos, segundos y otros campos). Vase struct tm
en asctime.
ahora = gmtime(&hoy);
Funciones relacionadas: asctime, ctime, ftime, localtime, time.
localtime #include <time.h>
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: asctime, gmtime, time.
mktime #include <time.h>
time_t mktime(struct tm *h);
Convierte la hora local a un valor de calendario. Vase struct tm en
asctime.
Funciones relacionadas: asctime, gmtime, localtime, time.
setdate #include <dos.h>
void setdate(struct date *f);
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; // ao actual
char da_day; // da mes
char da_mon; // mes, 1 para enero, 2...
};
En Visual C++ la funcin equivalente es _dos_setdate.
setdate(&fecha);
Funciones relacionadas: getdate, gettime, settime, dostounix.
settime #include <dos.h>
void settime(struct 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);
Funciones relacionadas: dostounix, gatdate, gettime, setdate.
stime #include <time.h>
int stime(time_t *t);
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);
Funciones relacionadas: dostounix.
strftime #include <time.h>
size_t strftime(char *cad, size_t maxlon,
const char *formato, const struct tm *t);
Convierte un puntero en una estructura tm en una cadena cad (con una
longitud mxima de n), utilizando f para dar formato a la cadena. El forma-
to es similar a printf().
horaseg = time(NULL);
horaactual = localtime(&horaseg);
strftime(buffer, 80, %A %B %d 19%y:I:%M, horaactual);
Funciones relacionadas: asctime, ctime, gmtime, localtime,
time.
time #include <time.h>
time_t time(time_t *h);
Proporciona el tiempo del sistema en segundos desde las 00:00:00 de
1/1/1970 tiempo GMT.
time(&hora);
tzset #include <time.h>
void tzset(void);
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: asctime, ftime, gmtime, localtime,
time.
unixtodos #include <time.h>
void unixtodos(long time, struct date *f, struct time *h);
Convierte a formato DOS un valor de hora en el formato UNIX.
tnixtodos(t_unix, &d_dos, ft_dos);
Funciones relacionadas: getdate, gettime, time, setdate, settime.
F.7. FUNCIONES DE CONTROL DE DIRECTORIOS
MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerrquico que
permite al usuario organizar sus archivos en directorios y subdirectorios.
Las funciones de control de directorios en Borland C++ proporcionan las
herramientas necesarias para crear, modificar, mover y eliminar directorios
desde sus programas C. Las funciones de manipulacin de directorios resi-
den en el archivo de cabecera dir.h.
chdir #include <dir.h>
int chdir(const char *camino);
Cambia el directorio de trabajo actual al directorio especificado en el
argumento camino. La funcin devuelve un 0 si tiene xito; en caso contra-
rio, devuelve un valor de 1 para asignar el error. Cuando se produce un
error, la variable global errno toma el valor ENOENT (camino o archivo no
encontrado).
if(chdir(\\)) {
perror(chdir());
exit(1);
}
Funciones relacionadas: mkdir, rmdir, setdisk, system.
findfirst #include <dir.h>
int findfirst(const char *camino, struct ffblk *ffblk, int atrib);
Busca en un directorio de disco hasta encontrar el primer archivo cuyo
nombre y atributos se corresponden con los valores especificados. El for-
mato de la estructura ffblk es:
struct ffblk {
char ff_reserved[21]; // reservada por DOS
char ff_atrib; // encontrado atributo
int ff_ftime; // hora archivo
int ff_date; // fecha archivo
long ff_fsize; // tamao archivo
char ff_name[13]; // encontrado nombre de archivo
};
La variable attrib viene definida en el archivo de cabecera <dos.h> y
puede ser igual a uno de estos valores:
FA_RDONLY Archivo de slo lectura.
FA_HIDDEN Archivo oculto.
FA_SYSTEM Archivo del sistema.
FA_LABEL Etiqueta de volumen.
FA_DIREC Directorio.
FA_ARCH Bit de archivo activado.
struct ffblk ffblk;
int t;
t = findfirst(*.*, &ffblk,0);
Funciones relacionadas: findnext.
findnext #include <dir.h>
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);
Funciones relacionadas: findfirst.
fnmerge #include <dir.h>
void fnmerge(char *camino, const char *u, const char *dir,
const *nombrearch, const char *ext);
Crea un nombre de camino completo compuesto de una letra de la uni-
dad (u), camino del directorio (dir), nombre de archivo (nombrearch) y
extensin del archivo (ext).
fnmerge(camino, c:, \\aux\\,demo,.dat);
Funciones relacionadas: fnsplit.
fnsplit #include <dir.h>
void fnsplit(const char *camino, char *u, char *dir,
char *nombrearch, char *ext);
Separa un nombre de camino completo en sus componentes: letra de la
unidad (u), camino del directorio, nombre del archivo y extensin del archi-
vo (ext).
h = fnsplit(camino, unidad, dir, nomarch, ext);
Funciones relacionadas: fnmerge.
getcurdir #include <dir.h>
int getcurdir(int u, char *dir);
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>
char *getcwd(char *camino, int numcar);
getcwd obtiene el nombre de camino completo del directorio de traba-
jo actual, incluyendo el nombre de la unidad. El argumento numcar indica
a getcwd el mximo nmero de caracteres que el buffer camino puede con-
tener. La funcin getcwd es til para obtener el nombre del directorio actual
y guardarlo. Si su programa cambia los directorios de trabajo durante su eje-
cucin, puede utilizar el nombre guardado para restaurar el directorio de tra-
bajo actual antes de terminar.
getcwd(cuentas, 80)
Funciones relacionadas: chdir.
getdisk #include <dir.h>
int getdisk(void);
La funcin getdisk obtiene el valor entero que representa la unidad
actual (0, unidad A; 1, unidad B...)
int unidad;
clscr();
unidad = getdisk();
Funciones relacionadas: setdisk.
mdir #include <dir.h>
int rmdir(const char *camino);
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 tra-
bajo rmdir(); devuelve 0 si la operacin de borrado tiene xito; si se pro-
duce un error, el valor devuelto es 1 y la variable global errno se fija a uno
de los siguientes valores:
EACCES Permiso denegado.
ENOENT Camino archivo no encontrado.
Esta funcin es similar a RMDIR o RD de MS-DOS.
rmdir(C:\\PRUEBAS); Supresin de directorio PRUEBAS
Funciones relacionadas: chdir, mkdir.
mkdir #include <dir.h>
int mkdir(const char *camino);
Crea un directorio con un nombre de camino especificado. Funciona
igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha
creado con xito o 1 si se produce un error; en este caso, la variable global
errno toma el valor EACCES (permiso denegado) o ENOENT (nombre de
camino no vlido).
EACCES Permiso denegado.
ENOENT Camino no encontrado.
resultado = mkdir(PRUEBAS);
// crea el directorio PRUEBAS
Funciones relacionadas: chdir, rmdir.
mktemp #include <dir.h>
char *mktemp(char *plantilla);
Crea un nombre de archivo a partir de una plantilla. Devuelve un pun-
tero al nombre del archivo si tiene xito y nulo en caso de error.
mktemp(nombre);
searchpath #include <dir.h>
char searchpath(const char *nombre);
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);
Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la
variable de entorno PATH.
buffer = searchpath(autoexec.bat);
Funciones relacionadas: getenv, putenv.
setdisk #include <dir.h>
int setdisk(int unidad);
Cambia a una nueva unidad por omisin. El valor de la unidad (unidad)
es un entero.
Unidad A
B:
C:
D:
...
nuevaunidad = setdisk(3); / nueva unidad actual es C:
Funciones relacionadas: getdisk
F.8. FUNCIONES DE CONTROL DE PROCESOS
Un proceso es un programa ejecutable en memoria y su entorno asociado.
Cada vez que se ejecuta un programa se crea un proceso.
En resumen, un proceso es un programa que se est ejecutando por el
sistema operativo. Consta del cdigo del programa y de datos, adems de
informacin relativa al proceso, tales como nmero de archivos abiertos.
Siempre que se ejecuta un programa al nivel del sistema operativo se arran-
ca un proceso.
Las funciones de control de proceso permiten arrancar, detener y ges-
tionar 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.
abort #include <process.h>
#include <stdlib.h>
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.
assert #include <assert.h>
void assert(int expresin);
Imprime un mensaje de error e interrumpe el programa si expresin es
falsa (0).
assert(string != NULL;
assert(*string != \0);
assert(strlen(string) < 2);
Funciones relacionadas: abort, raise, signal.
atexit #include <stdlib.h>
int atexit(void(*func)(void));
Procesa la funcin especificada al salir.
atexit(segundo);
Funciones relacionadas: abort, exit, _exit.
exec(familia) #include <process.h>
int excel(char *camino, char *arg0,...,NULL);
int execle(char *camino, char *arg0,..., *argn, NULL, char **env);
int execlp(char *camino, char *arg0, arg1,...,NULL);
int execlpe(char *camino, char *arg0,...argn, NULL, char **env);
int execv(char *camino, char argv[]);
int execve(char *camino, char argv[], char **env);
int execvp(char *camino, char *argv[]);
int execvpe(char *camino, char *argv[], char **env);
Cargan y ejecutan un proceso hijo en la memoria actualmente ocupada
por su 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.
exit #include <stdlib.h>
void exit(int estado);
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, atexit, exit, exit, fpreset,
spawn, system.
_exit #include <stdlib.h>
void _exit(int estado);
Termina inmediatamente el proceso actual sin hacer otras operaciones
auxiliares (como cierre de archivos).
_exit(0)
Funciones relacionadas: exit.
getenv #include <stdlib.h>
char *getenv(const char *nomvar);
Obtiene la definicin de una variable de la tabla de entorno del proce-
so. 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 #include <process.h>
unsigned getpid(void)
Obtiene el ID de proceso de un programa. Est disponible en sistemas
UNIX.
printf(PID:%X\n,getpid());
Funciones relacionadas: getpsp.
localeconv #include <locale.h>
struct lconv *localeconv(void);
Obtiene informacin detallada sobre formatos monetarios y numricos
de diferentes pases.
p_lconv = localeconv();
Funciones relacionadas: setlocale.
longjmp #include <setjmp.h>
void longjmp(jmp_buf env, int valor);
Restaura el estado de la pila y la ejecucin local anteriormente grabada
en env por setjmp.
longjmp(plaza, 3);
Funciones relacionadas: setjmp.
perror #include <stdio.h>
void perror(const char *cadena);
Imprime un mensaje de error del sistema en el flujo stderr. El argu-
mento 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 #include <stdlib.h>
int putenv(const char *cadena);
Crea nuevas variables de entorno o modifica los valores de las variables
de entorno existentes.
if(putenv(argv[1] == -1)
Funciones relacionadas: getenv.
raise #include <signal.h>
int raise(int seal);
Enva una seal al programa en ejecucin. Crea una condicin de
excepcin correspondiente al nmero seal. Existen diferentes constantes,
por ejemplo, SIGABRT (terminacin anormal).
printf(prueba de raise\n);
raise(SIGABRT);
Funciones relacionadas: abort, signal.
setjmp #include <setjmp.h>
int setjmp(jmp_buf env);
Guarda el estado actual del programa (el entorno de la pila) antes de lla-
mar a otra funcin. Este entorno puede ser restaurado por una llamada a
longjmp, realizando el efecto de un goto no local.
if(setjmp(env) != 0) printf(valor de longjmp\n);
Funciones relacionadas: longjmp.
signal #include <signal.h>
void (*signal(int sig, void (*func) (int))) (int);
Establece tratamiento de seales de interrupcin. La funcin signal per-
mite a un proceso elegir uno de los diferentes modos de manipular una seal
de interrupcin del sistema operativo.
signal(SIGINT, SIG_IGN);
Funciones relacionadas: abort, _control87, exit, longjmp, raise,
setjmp.
spawn (funciones) #include <stdio.h>
#include <process.h>
int spawnl(int modo, char *camino, char *arg0, char *arg1,...,NULL);
int spawnle(int modo, char *camino, char *arg0, char *arg1,...,NULL,
char **envp[]);
int spawnlp(int modo, char *camino, char *arg0, char *arg1,...,NULL);
int spawnlpe(int modo, char *camino, char *arg0, char *arg1,...,NULL,
char **envp[]);
int spawnv(int modo, char *camino, char *argv[]);
int spawnve(int modo, char *camino, char /argv[], char *envp[]);
int spawnvp(int modo, char *camino, char *argv[]);
int spawnvpe(int modo, char *camino, char *argv[], char *envp[]);
La familia de funciones spawn crea y ejecuta un nuevo proceso hijo.
Debe haber memoria suficiente para cargar y ejecutar el proceso hijo.
spawnlpe(P_WAIT, hijo.exe, hijo.exe, spawnlpe, buf,
NULL, env);
Funciones relacionadas: exec.
F.9. FUNCIONES DE CONVERSIN DE DATOS
Las funciones de conversin de tipos de datos sirven para crear un puente de
unin entre los dos estilos de representacin de nmeros: la cadena de texto
legible por los humanos y el formato binario legible por las mquinas. Las
funciones de conversin son ideales para convertir argumentos de lneas de
rdenes de su representacin de cadena al formato interno.
atof() #include <math.h>
#include <stdlib.h>
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]
opcional e/E
blancos o dgitos decimales
tabulaciones
La conversin termina cuando aparece el primer carcter no reconoci-
ble o cuando se encuentra un carcter nulo (\0).
double x;
char *cad_dbl = 200-85;
...
x = atof(cad_dbl); // convierte la cadena 200.85
a real
Funciones relacionadas: atoi, atol, ecvt, fcvt, gcvt, scanf,
strtod.
atoi #include <stdlib.h>
int atoi (const char *cadena)
La funcin atoi() convierte el argumento cadena en un valor entero.
La cadena debe tener el siguiente formato:
[espacio en blanco][signo][ddd]
opcional
espacio o tabulacin dgitos decimales
La conversin termina cuando se encuentra un carcter no reconocible
(carcter nulo, \0, punto decimal o una letra). Si no puede convertir la
cadena devuelve nulo.
int i;
char *cad_ent =123;
...
i = atoi(cad_ent);// convierte la cadena 123 al entero 123
Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa.
atol #include <stdlib.h>
long atol(const char *cadena);
Convierte el argumento cadena en un valor entero largo. La cadena debe
tener el formato:
[espacio en blanco][signo][ddd]
opcional
blancos y tabulaciones dgitos decimales
La conversin de caracteres de la cadena hasta que se encuentre el pri-
mer carcter no reconocible o el carcter nulo (\0).
long int i;
char cad_ent = 9876543;
...
i = atol(cad_ent); // convierte cadena 9876543 a entero
// largo.
Funciones relacionadas: atof, atoi, itoa, ltoa, scanf, strtod,
strtol, strtoul, ultoa.
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 infe-
riores 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);
Funciones relacionadas: atof, fcvt, gcvt, printf, sprintf, itoa,
ltoa, ultoa.
fcvt #include <stdlib.h>
char *fcvt(double valor, int n, int *dec, int *signo);
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 tra-
tar 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);
Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,
sprintf, ultoa.
gcvt #include <stdlib.h>
char *gcvt(double valor, int ndig, char, *buf);
La funcin gcvt() convierte el argumento valor de doble precisin en
una cadena de caracteres que se almacena en el buffer cuya direccin se da
en el argumento buf. Se debe asignar bastante espacio en el buffer para con-
tener todos los dgitos de la cadena convertida y el carcter nulo de termi-
nacin (\0).
gcvt(valor, digitos, cadena);
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf,
sprintf, ultoa.
itoa #include stdlib.h>
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.
ltoa #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 siste-
ma de numeracin. Como un entero largo ocupa 32 bits en base 2, la cade-
na puede ocupar 33 bytes con el carcter nulo de terminacin. Debe haber
bastante espacio para contener 33 bytes. ltoa() devuelve un puntero a cad.
long valor = 99288377L
ltoa(valor, cadena, 30);
Funciones relacionadas: atoi, atol, itoa, ultoa.
strtod #include stdlib.h>
double strtod(const char *cad, char **p);
La funcin strtod() convierte la cadena cad en un valor de doble
precisin. La cadena debe tener el formato
[blanco][signo][ddd][.][exponente][signo][ddd]
+, - d, D, e, E
blanco/ dgitos decimales
tabulacin
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 flo-
tante 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);
}
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.
strtol #include <stdlib.h>
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]
+, - dgitos decimales
hexadecimal
blancos y tabulaciones octal
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);
}
Funciones relacionadas: atoi, atof, atol, ltoa, strtoul.
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 carc-
ter 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);
Funciones relacionadas: atol, ultoa, strtol.
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 cdi-
go 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
Las funciones de E/S (Entrada/Salida, I/O, Input/Output) permiten leer y
escribir datos entre archivos y dispositivos. En C no hay estructuras de
archivos predefinidas, todos los datos se tratan como secuencias de bytes.
La lista de funciones de E/S se han agrupado de acuerdo a las tareas espec-
ficas que realizan:
1. Secuencias o flujos (stream).
2. Bajo nivel.
3. Consola y puertos.
Funciones de fIujos (stream)
Las funciones de E/S tratan los datos como una secuencia o flujo de carac-
teres individuales. La eleccin adecuada de las funciones disponibles per-
mite procesar datos en tamaos y formatos diferentes, desde caracteres inde-
pendientes a estructuras de datos complejos. La E/S por secuencia, o flujo,
tambin proporciona acciones de taponamiento (buffering) que mejoran sig-
nificativamente el rendimiento. Para utilizar los flujos, generalmente se
debe incluir el archivo stdio.h.
clearerr #include <stdio.h>
void clearerr(FILE *f);
Reinicializa el indicador de error de un flujo f.
clearerr(fichen);
Funciones relacionadas: eof, feof, ferror, perror.
fclose, fcloseall #include <stdio.h>
int fclose(FILE *f);
int fcloseall(void);
Cierra un flujo (fclose) o cierra todos los flujos abierta (fcloseall)
excepto stdin, stdout y stderr. Se devuelve el nmero de flujos cerrados
y EOF si se produce un error.
fcloseall();
Funciones relacionadas: close, fdopen, fopen.
fdopen #include <stdio.h>
FILE *fdopen(int handle, char *modo);
Abre un flujo utilizando un handle (entero devuelto por las rutinas de
E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una
estructura de datos FILE con el archivo especificado por handle.
p_datos = fdopen(handle, rb);
Funciones relacionadas: fclose, fopen, fropen, open.
feof #include <stdio.h>
int feof(FILE *flujo);
Comprueba el final de archivo de un flujo.
feof(fichen);
Funciones relacionadas: clearerr, fclose, rewind.
ferror #include <stdio.h>
int ferror(FILE *f);
Verifica si se ha producido un error en un flujo f.
ferror(fichen);
Funciones relacionadas: clarerr, eof, feof, fopen, perror.
fflush #include <stdio.h>
int fflush(FILE *f);
Limpia (vaca) un flujo. Los buffers se limpian automticamente cuan-
do estn llenos, cuando se cierra el flujo, o cuando un programa termina nor-
malmente sin cerrar el flujo.
fflush(fp);
Funciones relacionadas: fclose, flshall, fopen.
fgetc #include <stdio.h>
int fgetc(FILE * f);
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,
putchar.
fgetchar #include <stdio.h>
#int fgetchar(void);
Lee un carcter del archivo stdin, normalmente el teclado.
c = fgetchar();
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.
fgetpos #include <stdio.h>
int fgetpos(FILE *flujo, fpos_t *p);
Obtiene y graba la posicin actual del archivo. fos_t es un tipo defini-
do en stdio.h.
fgetpos(fp, &pos_archivo);
fgets #include <stdio.h>
char *fgets(char *cad, int n, FILE *f);
Lee una cadena de un flujo (hasta que se encuentra \n, o el nmero
mximo de caracteres especificados).
fgets(caddemo,80, fp);
Funciones relacionadas: fputs, gets, puts.
fileno #include <stdio.h>
int fileno(FILE *f);
Obtiene el mando o manejador (handle) del archivo asociado con un
flujo.
fileno(stdin);
Funciones relacionadas: fdopen, fopen.
fopen #include <stdio.h>
FILE *fopen(const char *f, const char *modo);
Abre un archivo f. La cadena de caracteres modo especifica el tipo de
acceso.
Modo Accin
r Abre para lectura.
w Abre un archivo vaco para escritura.
a Abre para escritura al final del archivo (aadir).
r+ Abre para lectura/escritura.
w+ Abre un archivo vaco para lectura/escritura.
a+ Abre para lectura y aadir.
rb Abre un archivo binario para lectura.
wb Crea un archivo binario para escritura.
ab Abre un archivo binario para aadir.
rb Abre un archivo binario para lectura/escritura.
wb Crea un archivo binario para la lectura/escritura.
ab Abre o crea un archivo binario para lectura/escritura.
if ((corriente2 = fopen(datos, W+)) == NULL
printf(el archivo..no se ha abierto \n);
Funciones relacionadas: fclose, fcloseall, fdopen, ferror,
fileno, freopen, open, setmode.
flushall #include stdio.h>
int flushall(void);
Vaca (limpia) todos los buffers asociados con los archivos abiertos.
numvaciados = flushall();
Funciones relacionadas: fclose, fflush.
fprintf #include <stdio.h>
int fprintf(FILE *f, const char *formato[arg,...]);
Imprime datos con formato en un flujo.
fprintf(f1,El resultado es %f\n,result);
Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
fputc #include <stdio.h>
int fputc(int c, FILE *f);
Escribe un carcter c en el flujo abierto para salida con buffer.
fputc(*(p++), stdout);
Funciones relacionadas: fgetc, fgetchar, fputchar, getc, get-
char, putc.
fputchar #include <stdio.h>
int fputchar(int c);
Escribe el carcter c en stdout.
fputchar(q);
Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar.
fputs #include <stdio.h>
int fputs(const char *cad, FILE *f);
Escribe una letra cad en un flujo f. Devuelve el ltimo carcter impre-
so, si hay error devuelve EOF.
fputs(esto es una prueba, f1);
Funciones relacionadas fgets, gets, puts.
fread #include <stdio.h>
size_t fread(void *p, size_t t, size_t n, FILE *f);
Lee n registros de t bytes en la memoria apuntada por p desde el flujo f.
fread(buf, strlen(msg)+1, 1, flujo);
Funciones relacionadas: fwrite, read.
freopen #include <stdio.h>
FILE *freopen(const char *f, const char *m, FILE *flujo);
Cierra el archivo asociado con flujo y reasigna flujo al archivo espe-
cificado por f. Los modos (m) utilizados son los mismos de fopen.
freopen(salida.txt, w, stdout);
Funciones relacionadas: fclose, fopen.
fscanf #include <stdio.h>
int fscanf(FILE *f, const char *formato [, direccin,...]);
Lee datos con formato de un flujo.
fscanf(flujo, %s%f, cad, &f);
Funciones relacionadas: csanf, fprintf, scanf, sscanf.
fseek #include <stdio.h>
int fseek(FILE *f, long desp, int org);
Mueve el puntero del archivo asociado con f a una nueva posicin que
est desplazada desp bytes de org.
Origen Significado
SEEK_SET Principio de archivo.
SEEK_CUR Posicin actual puntero archivo.
SEK_END Final de archivo.
fseek(f1,OL,SEEK_SET); // ir al principio
Funciones relacionadas: ftell, rewind, fopen.
fsetpos #include <stdio.h>
int fsetpos(FILE *f, const fpos_t *p);
Establece la posicin del puntero del archivo al lugar especificado por
el objeto apuntado por p.
fsetpos(fp, &posarch);
Funciones relacionadas: getpos.
ftell #include <stdio.h>
long int ftell(FILE *f);
Obtiene la posicin actual (puntero) del archivo asociado con el flujo f.
ftell(fichen);
Funciones relacionadas: fgetpos, fssek, tell.
fwrite #include <stdio.h>
size_t fwrite(const void *p, size_t l, size_t n, FILE *f);
Escribe n elementos (registros) de longitud l desde la memoria apunta-
da 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: fread, fscanf, getc, fgetc.
getc #include <stdio.h>
int getc(FILE *f);
Devuelve el siguiente carcter de un flujo de entrada dado e incremen-
ta la posicin actual del puntero del archivo. Si se alcanza el final de archi-
vo, se devuelve EOF.
whilec(c = getc(fx)!= EOF) {
printf(%c, c);
}
Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc,
putchar, fopen.
getch #include <stdio.h>
int getch(void)
Lee un carcter del teclado sin hacer eco en la pantalla.
do {
car = getch();
char = toupper(car);
} while(car != S);
Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.
getchar #include <stdio.h>
int getchar(void);
Devuelve el siguiente carcter de stdin. Si se alcanza el final de archi-
vo, se devuelve EOF.
int c;
while((c = getchar())!= \n)
printf(%c, c);
Funciones relacionadas: fgetc, fgetchar, getch, getche, putc,
putchar, ungetc.
getche #include <stdio.h>
int getche(void);
Lee un carcter del teclado haciendo eco del carcter en la pantalla.
resp= getche();
Funciones relacionadas: cgets, getch, getchar, ungetch.
gets #include <stdio.h>
char *gets(char *cad);
Lee una lnea desde el archivo de entrada estndar stdin, por omisin
es el teclado y lo guarda en cad.
gets(nombre);
Funciones relacionadas: fgets, fputs, puts.
getw #include <sdio.h>
int getw(FILE *f);
Lee un entero (o una palabra de dos bytes) de un flujo f.
suma = getw(fx) + suma;
Funciones relacionadas: fread, putw.
printf #include <stdio.h>
int printf(const char *formato[,argumento,...]);
Escribe cadenas de caracteres y valores de variables, con formato, en el
archivo de salida estndar stdout (por omisin, la pantalla).
Cdigo Formato
%c Carcter.
%d Entero decimal.
%e Real (double o float), notacin cientfica.
%f Coma flotante.
%s Cadena de caracteres.
%x Hexadecimal sin signo.
printf(producto %d y %d es %d\n,x,y, x*y);
Funciones relacionadas: fprintf, scanf, sprintf, viprintf,
vprintf, vsprintf.
putc, putchar #include <stdio.h>
int putc(int c, FILE *f);
int putchar(int c);
Escribe un carcter en un flujo (putc) o en stdout (putchar).
putc(*, demo);
Funciones relacionadas: fputc, fputchar, getc, getchar.
putch #include <stdio.h>
int putch(int c);
Escribe un carcter en la pantalla.
putch(B);
Funciones relacionadas: putc, putchar.
puts #include <stdio.h>
int puts(const char *cad);
Escribe una cadena en el archivo de salida estndar stdout.
puts(Desea continuar(s/n?);
Funciones relacionadas: fgets, fputs, gets.
putw #include <stdio.h>
int putw(int i, FILE *f);
Escribe un entero en un flujo f.
putw(100, fx);
Funciones relacionadas: getw, printf.
rewind #include <stdio.h>
void rewind(FILE *f);
Reinicializa el puntero del archivo al principio de un flujo.
rewind(fx);
Funciones relacionadas: fseek.
scanf #include <stdio.h>
int scanf(const char *formato[,direccin,...]);
Lee datos con formato del flujo de entrada estndar.
Cdigo Formato
%c Carcter.
%d Entero decimal.
%x Hexadecimal.
%i Entero decimal.
%f Nmero real.
%o Octal.
%p Puntero.
%s Cadena.
scanf(%d %f %c %s, &i, &fp, &c, s);
Funciones relacionadas: fscanf, printf, sscanf, vfprintf,
vprintf, vsprintf
setbuf #include <stdio.h>
void setbuf(FILE *f, char *buffer);
Asigna un buffer a un flujo.
setbuf(fx, buffer);
Funciones relacionadas: setvbuf.
setvbuf #include <stdio.h>
int setvbuf(FILE *f, char *b, int t, size_t l);
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);
Funciones relacionadas: setbuf.
sprintf #include <stdio.h>
int sprintf(char *b, const char *f[,arg,...]);
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);
Funciones relacionadas: sprintf, printf, vprintf, vfprintf,
vsprintf.
sscanf #include <stdio.h>
int sscanf(const char *b, const char *f[,direccin,...]);
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.
tmpfile #include <stdio.h>
FILE *tmpfile(void);
Crea un archivo temporal y devuelve un puntero a ese flujo.
if((aux = tmpfile()) == NULL)...
Funciones relacionadas: tmpnam.
tmpnam #include <stdio.h>
char *tmpnam(char *s);
Genera un nico nombre de archivo y lo guarda en el array apuntado por s.
tmpnam(prueba);
Funciones relacionadas: tmpfile.
ungetc #include <stdio.h>
int ungetc(int c, FILE *f);
Sita un carcter, excepto la constante EOF, en el buffer asociado con un
archivo abierto para entrada con buffer.
ungetc(car, stdin);
Funciones relacionadas: getc.
ungetch #include <stdio.h>
int ungetch(int ch);
Empuja un carcter en la memoria intermedia del teclado.
char ch;
ch = getch();
ungetch(ch);
vfprintf, #include <stdio.h>
vprintf, #include <stdarg.h>
vsprintf
int vfprintf(FILE *f, const char *f, lista_va lista_arg);
int vprintf(const char *f, lista_va lista_arg);
int vsprintf(char *b, const char *f, lista_va lista_arg);
Escribe salida con formato utilizando un puntero a una lista de argu-
mentos.
vprintf(formato, nota);
Funciones relacionadas: fprintf, printf, sprintf, va_arg,
va_end, va_strat.
vfscanf #include <stdio.h>
#include <stdarg.h>
int vfscanf(FILE *F, const char *f, lista_va lista_arg);
Lee entrada con formato de un flujo, tal como scanf, excepto que vfs-
canf acepta un puntero a la lista de argumentos.
vfscanf(demo, formato, arg);
Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf.
vscanf #include <stdio.h>
int vscanf(const char *f, lista_va lista_arg);
Lee una entrada con formato de un flujo; similar a scanf, excepto que
vscanf acepta un puntero a la lista de argumentos.
vscanf(formato, argumento);
Funciones relacionadas: fscanf, scanf, sscanf, fsca.
vsscanf #include <stdio.h>
#include <stdarg.h>
int vsscanf(const char *b, const char *f, lista_va
lista_arg);
Funciona igual que sscanf, excepto que en vsscanf es utilizado un
puntero a una lista de variables en lugar de a las propias variables.
vsscanf(buf_en, formato_p, arg_p);
Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.
Funciones de bajo niveI
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.
_close, close #include <io.h>
int _close(int h);
int close(int h);
Cierra el archivo especificado en h. Estas funciones se utilizan con
_open y open.
close(f1);
Funciones relacionadas: fclose, fopen, open.
_creat #include <io.h>
creat #include <sys\stat.h>
#include <dos.h>
int creat(const char *cam, int modo);
int _creat(const char *cam, int atributo);
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.
Modo Significado
S_IWRITE Permiso de escritura.
S_IREAD Permiso de lectura.
S_IREAD|S_IWRITE Permiso de lectura y escritura.
fh= creat(datos,S_IREAD|S_IWRITE);
Funciones relacionadas: chmod, close, open umask.
creatnew #include <io.h>
#include <dos.h>
int creatnew(const char *camino, int atributo);
Crea un archivo nuevo con los atributos especificados.
h = creatnew(F.FIL,0);
Funciones relacionadas: _creat, fopen, open.
creattemp #include <io.h>
#include <dos.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
Funciones relacionadas: tmpfile.
dup, dup2 #include <io.h>
int dup(int h);
int dup2(int h1, int h2);
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace
de archivo (dup2).
viejostdout = dup(STDOUT);
dup2(fptr, STDOUT);
Funciones relacionadas: close, creat, open.
eof #include <io.h>
int eof(int d);
Comprueba si el archivo especificado en el descriptor d es el final de
archivo (se devuelve 1 si se alcanza el final del archivo. 0 si no se alcanza
el final del archivo, 1 indica un error y errno toma valor EBADF: nmero
de archivo incorrecto).
while(!eof(fx))
Funciones relacionadas: feof, ferror, perror.
lseek #include <io.h>
#include <stdio.h>
long lseek(int d, long desp, int origen);
La funcin lseek mueve el puntero asociado con el descriptor d a una
nueva posicin que est emplazada desp bytes de origen.
pos = lseek(fh, OL, SEEK_CUR);
Funciones relacionadas: fseek, tell.
open #include <fcntl.h>
#include <io.h>
#include <sys\stat.h>
int open(const char *f, int a[, unisgned m]);
Abre el archivo especificado en f para lectura o escritura. El argumen-
to a indica el tipo de operacin permitida y m el tipo de permiso.
Indicador
Significado
Lectura/escritura
O_RDONLY Abrir para lectura.
O_WRONLY Abrir para escritura.
O_RDWR Abrir para lectura y escritura.
O_NDELAY Pone el puntero del archivo al final del archivo.
O_APPEND Se crea el archivo y se fijan atributos del archivo.
O_TRUNC Trunca el archivo a 0.
O_EXCL Se utiliza con O_CREAT.
O_BINARY Abrir archivo en modo binario.
O_TEXT Abrir archivo en modo texto.
open(OPEN.OUT, 0_WRONLY|O_CREAT, S_IREAD|IWRITE);
if((h = open(open.tst, O_CREAT))==1)...
Funciones relacionadas: access, chmod, close, creat, fopen.
sopen #include <fcntl.h>
#include <io.h>
#include <share.h>
#include <sys/stat.h>
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
Significado
Lectura/escritura
O_RDONLY Abrir para lectura.
O_WRONLY Abrir para escritura.
O_RDWR Abrir para lectura y escritura.
S_IWRITE Acceso de escritura.
S_IREAD Acceso de lectura.
S_IWRITE|S_IREAD Acceso de lectura y escritura.
df = sopen(C:||autoexec.bat, O_RDONLY, SH_DENYRW, S_IREAD);
Funciones relacionadas: close, fopen.
read #include <io.h>
int read (int d, void * buffer, unsigned lon);
Lee lon bytes del archivo asociado con d en el buffer apuntado por
buffer.
read(fx, buffer, 100);
tell #include <io.h>
long tell(int d);
Devuelve la posicin actual del puntero del archivo especificado por d.
posi = tell(desf);
Funciones relacionadas: ftell, lseek.
write #include <io.h>
int write(int d, void *buffer, unsigned lon);
Escribe datos en un archivo (lon bytes en el archivo asociado con d
desde el buffer apuntado por buffer).
write(fx, grande, 60000);
Funciones relacionadas: creat, open, read, sopen.
Funciones de consoIa y puertos de E/S
Las funciones de E/S sirven para interactuar con el teclado y la pantalla.
Estas funciones se declaran en el archivo de cabecera conio.h.
cgets #include <conio.h>
char *cgets(char *cadena);
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);
Funciones relacionadas: cputs, getch, getche.
cprintf #include <conio.h>
int cprintf(const char *formato[,arg,...]);
Escribe salida con formato directamente en la consola. Observe que
cprintf no traduce el carcter (\n) a una combinacin (CR-LF), en su lugar,
\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);
Funciones relacionadas: printf.
cputs #include <conio.h>
int cputs(const char *cad);
Escribe una cadena en la pantalla. No se enva ningn carcter de nueva
lnea despus de la cadena.
cuts(Est usted seguro(s/n)?);
Funciones relacionadas cprintf.
cscanf #include <conio.h>
int 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: fscanf, scanf, sscanf.
get, getche #include <conio.h>
int getch(void);
int getche(void);
Lee un carcter de la consola sin eco (getch) o con eco (getche).
printf(Pulse cualquier tecla para salir);
getch();
Funciones relacionadas: cgets, getchar, ungetch.
getpass #include <conio.h>
char *getpass(const char *indicador);
Lee una palabra de paso por consola, que no se visualiza en pantalla
(menos de ocho caracteres de longitud).
palabrapaso = getpass(Introduzca clave);
Funciones relacionadas: getch
inport, inportb #include <dos.h>
int inport(int puerto);
unsigned char inportb(int puerto);
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);
Funciones relacionadas: outport, poutportb.
kbhit #include <conio.h>
int kbhit(void);
Comprueba si se ha pulsado recientemente una tecla.
// visualizar hasta que pulsa una tecla
while(!kbhit())
cputs(Pulse una tecla);
Funciones relacionadas: getch, getche.
outport, outportb #include <conio.h>
void outport(int puerto, int palabra);
void outportb(int puerto, unsigned char byte);
Escribe una palabra de 16 bits (outport) un byte (outportb) en un
puerto de E/S.
outport(23,0); // 23 fuera del puerto
outport(A, 0) // A fuera de puerto
Funciones relacionadas: inp, inport, inportb, inpw.
putch #include <conio.h>
int putch(int c);
Escribe un carcter en la consola (sin accin del buffer).
putch(car); putch(\n); putch(x);
Funciones relacionadas: getch, getche.
ungetch #include <conio.h>
int ungetch(int c);
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: getch, getche, ungetc.
F.11. FUNCIONES DE GESTIN DE ARCHIVOS
El sistema de archivos es un componente clave del/de la PC. Todas las apli-
caciones y datos residen en archivos. Las funciones de 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 #include <io.h>
int access(const char *nomarch, int modo);
Verifica si existe un archivo y, en caso afirmativo, los permisos de acce-
so al archivo.
Modo Significado
00 Se verifica existencia del archivo.
01 Ejecutar.
02 Verifica permiso de escritura.
04 Verifica permiso de lectura.
06 Verifica permiso de lectura y escritura.
return(access(nombre, 4)==-1)
Funciones relacionadas: chmod, fstat, stat.
chmod #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);
Funciones relacionadas: access, fstat, stat.
pmodo Permiso de acceso
S_IWRITE Escritura.
S_IREAD Lectura.
S_IREAD|S_IWRITE Lectura/Escritura.
chsize #include <io.h>
int chsize(int manejador, long longitud);
Cambia el tamao del archivo.
chsize(fh, 5);
Funciones relacionadas: access, chmod, fstat, stat.
filelength #include <io.h>
long filelenght(int manejador);
Obtiene la longitud de un archivo en bytes.
filelength(fh);
Funciones relacionadas: fileno, filestat, stat.
fnmerge #include <dir.h>
void fnmerge(char *camino, const char *unidad,
const char *dir, const char *nombref, const char *ext);
Crea un nombre de camino completo (letra, unidad, camino directorio,
nombre de archivo y extensin del archivo). En Microsoft, la funcin equi-
valente es _makepath.
fnmerge(camino,C:,\\aux,resultado,.dat);
// nombre de caminoC:\aux\resultado.dat
Funciones relacionadas: fnsplit.
fnsplit #include <dir.h>
int fnsplit(const char *camino, char *unidad,
char *dir, char *fnombre, char *ext);
Separa un nombre de camino completo en sus componentes: letra, uni-
dad, camino, nombre y extensin del archivo.
f = fnsplit(c, unidad, dir, arch, ext);
Funciones relacionadas: fnmerge.
fstat #include <sys\stat.h>
int fstat(int h, struct stat *buffer);
Devuelve informacin sobre el archivo especificado en la estructura de
tipo stat apuntada por buffer. La estructura stat es:
struct stat {
short st_dev; // unidad o dispositivo
short st_ino; // nmero inodo (UNIX)
short st_mode // modo archivo
short st_nlink; // nmero enlaces (DOS,1)
int st_uid; // id de usuario (UNIX)
int st_gid; // id de grupo (slo UNIX)
int st_rdev; // dispositivo UNIX
long st_size; // tamao archivo en bytes
long st_atime; // hora ltimo acceso
long st_mtime; // hora ltima (UNIX)
long st_ctime; // hora creacin
};
fstat(fich, &info);
Funciones relacionadas: access, chmod, stat.
isatty #include <io.h>
int isatty(int h);
Determina si es un dispositivo orientado a carcter (terminal, consola,
impresora o puerto serie).
if(isatty(fileno(stdout)))
puts(es consola);
lock #include <io.h>
int lock(int h, long d, long n);
Bloquea un nmero de bytes n del archivo h (manejador) con desplaza-
miento se utiliza para comparticin de archivos (orden SHARE de MS-
DOS). En Visual C++, la funcin equivalente es locking.
res lock(h, 0L,256); bloque de 256 bytes
Funciones relacionadas: sopen, unlock.
mktemp #include <dir.h>
char * mktemp(char *plantilla);
Crea un nico nombre de archivo modificando una plantilla dada como
argumento, plantilla toma la forma basexxxxxx, donde base es el nom-
bre que se proporciona y x los caracteres a modificar.
char modelo = tcbxxxxxx;
mktemp(modelo);
Funciones relacionadas: tmpfile, tmpnam.
remove #include <stdio.h>
int remove(const char *camino);
Borra el archivo especificado en camino.
remove(C:\\ux\\demo); // borra demo
Funciones relacionadas: unlink.
rename #include <stdio.h>
int rename(const char *vn, const char *nn);
Renombre el archivo vn a nn.
int resultado;
resultado = rename(viejo, nuevo);
Funciones relacionadas: creat, fopen, open.
setmode #include <io.h>
#include <fcntl.h>
int setmode(int h, int modo);
Permite cambiar el modo del archivo abierto entre texto y binario.
modo 0_BINARY(binario) 0_TEXT(texto)
setmode(fileno(stdin), 0_BINARY);
// modo binario
Funciones relacionadas: fopen, open.
stat #include <sys\stat.h>
int stat(char *f, struct stat *buffer);
Obtiene informacin sobre el estado de un archivo existente f.
resultado = stat(stat.c,&buf);
Funciones relacionadas: access, chmod, fstat.
umask #include <io.h>
unsigned umask(unsigned Pmodo);
Establece la mscara de permisos de lectura/escritura usados por open
y create.
Pmodo S_IREAD (slo lectura)
S_IWRITE (slo escritura)
S_IREAD|S_IWRITE (lectura/escritura)
viejamascara = umask(S_IWRITE);
Funciones relacionadas: chmod, creat, mkdir, open, sopen.
unlink #include <dos.h>
#include <io.h>
#include <stdio.h>
int unlink(const char *camino);
Borra un archivo especificado en camino, que no sea de slo lectura.
result = unlink (demo.jnk);
if (result==0)
printf (unlink tuvo xito);
Funciones relacionadas: remove.
unlock #include <conio.h>
int unlock(int h, long o, long l);
Desbloquea una seccin del archivo h que ha sido bloqueada con lock.
unlock(m,OL,256); // desbloquea 256 bytes
Funciones relacionadas: lock, sopen.
F.12. FUNCIONES MATEMTICAS
El C original de K&R fue diseado, inicialmente, como un lenguaje de pro-
gramacin 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 flo-
tante 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 Bor-
land C++ no incluidas en ANSI C son: cabs, _clear87, _control87,
_fpreset, hypot, _lrotl, _rotr, _matherr, matherrmax, min,
poly, pow10, random, randomize, _rotl, _rotr, _status87.
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.
CIase compIex
Borland C++ incluye una estructura complex en el archivo de cabecera
math.h, cuyos miembros son la parte real e imaginaria de un nmero com-
plejo z y que se define as:
struct complex
{
double x; // parte real del nmero complejo
double y; // parte imaginaria del complejo
}
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;
Las funciones complejas son propias de Borland C++ y no son expor-
tables.
CIase bcd
La clase bcd permite manipular nmeros almacenados en notacin decimal
codificado a binario (BCD) y proporciona hasta 17 dgitos decimales de
precisin, y un rango de 1 10
-125
a 1 10
125
.
abs versin real #include <math.h>
#include <stdlib.h>
versin compleja #include <complex.h>
int abs (int x);
double abs(complex x);
Proporciona el valor absoluto de un entero o de un nmero complejo:
abs(-50) devuelve 50. Para utilizar nmeros complejos se requiere el
archivo de cabecera complex.h.
x = abs(-7) // x es 7
Funciones relacionadas: cabs, fabs, labs.
acos #include <math.h>
#include <complex.h>
double acos(double x);
complex acos(complex x);
La funcin acos() devuelve el arco coseno de x, cuyo valor debe estar
en el rango 1 a 1. El resultado es un valor (ngulo) entre 0 y radianes.
angulo = acos(0.5); // el ngulo devuelto es /3
Funciones relacionadas: cos, matherr.
arg #include <complex.h>
double arg(complex x);
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);
Funciones relacionadas: complex, norm, polar.
asin versin real #include <math.h>
double asin(double x);
Calcula el arco seno del argumento x; el valor de x debe estar com-
prendido 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: matherr, sin.
atan versin real #include <math.h>
double atan(double x);
Calcula el arco tangente de x. El rango x es 1 a 1. La funcin atan()
devuelve un valor en el rango de /2 a /2.
complex atan(complex x);
angulo = atan(1.0); // ngulo es Pi/4 (45 grados)
Funciones relacionadas: atan2.
atan2 #include <math.h>
double atan2 (double y, double x);
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 #include <math.h>
double babs(struct complex z);
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);
Funciones relacionadas: fabs, hypot, matherr, sqrt.
ceil #include <math.h>
double ceil (double x);
Calcula (redondea) el nmero entero mayor que o igual a x.
redondeo = ceil(5.1) // redondeo es 6
Funciones relacionadas: floor.
_clear87 #include <float.h>
unsigned int _clear87(void);
Borra (limpia) la palabra del estado de coma flotante.
estado = _clear87();
Funciones relacionadas: _control87, _status87.
_control87 #include <float.h>
unsigned int _control87(unsigned int nuevo, unsigned int
mascara);
Obtiene y establece la palabra de control de coma flotante. Cuando se
utiliza un coprocesador matemtico 8087, _control87 establece su palabra
de control.
estado = control87(PC24,MCW_IC);
// precisin 24 bits
Funciones relacionadas: _clear87, _status87.
cos #include <math.h>
double cos(double x);
complex cos(complex x);
Calcula el coseno del argumento x. El argumento x se especifica en
radianes y devuelve un valor en el rango de 1 a 1.
coseno_x = cos(1.6543);
Funciones relacionadas: acos, sin.
cosh #include <math.h>
double cosh(double x);
complex cosh(complex x);
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);
Funciones relacionadas: sinh.
div #include <stdlib.h>
div_t div(int x, int y);
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; // cociente
int rem; // resto
} div_t;
div_t resultado;
resultado = div(35, 8);
// resultado.cociente = 4, resultado.resto = 3
exp #include <amth.h>
double exp(double x);
complex exp(complex x);
Calcula el exponencial de x:e
x
; donde e es la base del logaritmo natu-
ral (e = 2.7182818).
x = 100.00;
y = exp(x);
printf(El exponencial de x = %f.\n,y);
Funciones relacionadas: log, pow.
fabs, fabsl #include <math.h>
double fabs(double x);
long double fabs(long double x);
Calcula el valor absoluto de un nmero en coma flotante x.
y = fabs(-7.25); // y vale 7.25
Funciones relacionadas: cabs.
floor #include <math.h>
double floor(double x);
Redondea por defecto el valor de x.
x = floor(6.25); // x vale 6
Funciones relacionadas: ceil.
fmod #include <math.h>
double fmod(double x, double y);
Calcula el resto de la divisin real x por y.
resto = (fmod(5.0, 2.0); // resto igual a 1.0
Funciones relacionadas: floor.
_fpreset #include <float.h>
void _fpreset(void);
Reinicializa el paquete matemtico de coma flotante. Debe utilizarse
despus de las llamadas a las funciones system(), exec(), span() sobre
mquinas con coprocesadores matemticos.
_fpreset(); // inicializa paquete de coma flotante *t
Funciones relacionadas: _control87, signal.
frexp(), frexpl() #include <math.h>
double frexp(double x, int *exp);
long double frexpl(long double x, int *exp);
La funcin frexp descompone el valor x en una mantisa (m) y en un
exponente n, tal que el valor absoluto de m es mayor o igual a 0,5 y menor
que 1,0 y x + m*2
n
. La mantisa se obtiene por la funcin, y el exponente se
almacena en la variable apuntada por exp.frexpl descompone un valor
long double.
double x, y;
int n;
x = 17.5;
y = frexp(x, &n);
printf(frexp(%f, &n) = %f, n = %d\n,x,y,n);
Funciones relacionadas: exp, ldexp, modf.
hypot #include <math.h>
double hypot(double x, double y);
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);
double x = 3.0; y = 4.0;
printf(%lf, hypot(x, y));
imag #include <complex.h>
double imag(complex x);
Devuelve la parte imaginaria de un nmero complejo x. Esta funcin no
es transportable.
double x = 3.4, y = 4.5;
complex = complex(x, y);
cout << parte imaginaria: << imag(z) << \;
Funciones imaginarias: complex, conj, real.
labs #include <math.h>
long int labs(long int n);
Calcula el valor absoluto de un entero largo (n).
long lx = 51654L, ly;
ly = labs(lx);
Funciones relacionadas: abs, cabs, fabs.
ldesp, ldespl #include <math.h>
double ldesp(double x, int exp);
long double ldexpl(long double x, int exp);
Calcula y devuelve el valor real de x*e
exp
.
double x = 4.0,y;
int p = 5;
y = ldexp(x, p);
Funciones relacionadas: frexp, modf.
ldiv #inxlude <stdlib.h>
ldiv_t ldiv(long int x, long int y);
Calcula el cociente y el resto de la divisin x/y. La funcin ldiv
devuelve una estructura de tipo ldiv_t que comprende el cociente y el
resto.
typedef struct
{
long quot;
long rem;
} ldiv_t;
long x = 5258625, y = 341654;
ldiv_t resultado;
resultado = ldiv(x, y);
printf(el cociente y el resto es %ld, %ld,\n, resultado.quot,
resultado.rem);
Funciones relacionadas: div.
log, log10 #include <math.h>
double log(double x);
double log10(double x);
Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x.
Si x es negativo, ambas funciones devuelven un error de dominio DOMAIN en
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);
Funciones relacionadas: exp, matherr pow.
_lrotl #include <stdlib.h>
unsigned long _lrotl(unsigned long x, int c);
Se utiliza _lrotl para rotar a la izquierda los bits de una variable ente-
ra larga sin signo x. La rotacin de un bit a la izquierda, una posicin, sig-
nifica 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);
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);
Funciones relacionadas: _lrotl, _rotl, _rotr.
matherr #include <math.h>
_matherrl
int matherr(struct exception *e);
int _matherrl(struct _exception1 *e)
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 #include <conio.h>
(tipo) max(a, b);
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: min.
min #include <stdlib.h>
(tipo) min(a, b);
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: max.
modf, modfl #include <math.h>
double modf(double x, double *partent);
long double modfl(long double x, long double *partent);
La funcin modf divide un nmero de coma flotante en dos partes, ente-
ra y decimal. La parte entera de x se almacena en la posicin a cuya direc-
cin apunta partent, y la parte decimal es devuelta por la funcin.
pardecimal = modf(36.95, &parte_entera(;
// parte entera 36, parte decimal .95
Funciones relacionadas: frexp,ldexp.
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);
Funciones relacionadas: Slo existe en C+.
poly #include <math.h>
double poly(double x, int n, double c[]);
Se utiliza poly para evaluar un polinomio en x, de grado n y cuyos coe-
ficientes son los correspondientes al array c. La expresin utilizada para
evaluar el polinomio es:
c[n]x
n
+c[n-1]
n-1
+...+c[2](x
2
+c[1](x+c[0]
// polinomio: 3x**2 + 2x + 1//
double c[] = {-10.0,2,c);
Funciones relacionadas: pow.
rand #include <stdlib.h>
int rand(void);
Genera un nmero pseudoaleatorio en el rango de 0 a RAND_MAX; esta
constante simblica est definida en <stdlib.h> y su valor es 2
15
-1. Para ini-
cializar 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: random, randomize, srand.
random #include <stdlib.h>
int random(int x);
Genera un nmero pseudoaleatorio en el rango de 0 a x-1.
// obtener un nmero aleatorio entre 0 y 20
numa1 = random(21);
Funciones relacionadas: rand, randomize.
randomize #include <stdlib.h>
#include <time.h>
void randomize(void);
Inicializa (genera una semilla) el generador de nmeros pseudoaleato-
rios con una semilla aleatoria que es funcin de la hora actual. Esta funcin
impide que se repitan las mismas secuencias de nmeros aleatorios en dife-
rentes ejecuciones.
randomize();
Funciones relacionadas: rand, random, srand.
real #include <complex.h>
#include <bcdh.h>
double real(complex x);
double real(bcd x);
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 #include <stdlib.h>
unsigned _ rotl(unsigned x, int c);
Rota el valor de x,c bits a la izquierda.
modelo_nuevo = _rotl(0x1234,8);
// resultado es 3412h
Funciones relacionadas: _lrotl, _rotr, _rotr.
_rotr #include <stdlib.h>
unsigned _rotr(unsigned x, int c);
Se utiliza _rotr para rotar a la derecha el valor de x,c bits.
_rotr(val, 4);
Funciones relacionadas: _lrotl, _lrotr, _rotl.
sin #include <math.h>
double sin(double x);
complex sin(complex x);
La funcin sin() proporciona el seno de x (se supone en radianes).
double x, y;
x = 0.52;
printf(x = %f radianes\n, x);
y = sin(x)
printf(el seno de x = %f\n, y);
Funciones relacionadas: asin, cos, sinh.
sinh #include <math.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.
sqrt #include <math.h>
double sqrt(double x);
complex sqrt(complex x);
Calcula la raz cuadrada de un nmero x no negativo.
printf(%lf,sqrt(25.0); // se visualiza 5
Funciones relacionadas: exp, log, pow.
srand #include <stdlib.h>
void srand(unsigned x);
srand inicializa el generador de nmeros aleatorios con la semilla x. Si
x es 1, el generador se reinicializa; cualquier otro valor de x fija el genera-
dor a un punto inicial aleatorio.
srand(semilla);
Funciones relacionadas: rand, randomize.
_status87 #include <float.h>
unsigned int _status87(void);
Obtiene el contenido de la palabra de estado de coma flotante.
estado = _status87();
Funciones relacionadas: _clear87, _control87.
tan #include <math.h>
double tan(double x);
complex tan(complex x);
Calcula la tangente de x (x, se supone en radianes).
y = tan(x)
Funciones relacionadas: atan.
tanh #include <math.h>
double tanh(double x);
complex tanh(complex x);
Calcula la tangente hiperblica de x.
a = tanh(x);
Funciones relacionadas: cosh, tanh.
F.13. FUNCIONES DE MANIPULACIN DE BLOOUES
DE MEMORIA (BUFFERS)
Las rutinas de manipulacin de buffers son una forma general de las rutinas
de manipulacin de cadenas que operan sobre stas en C. Son tiles para tra-
bajar 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 buf-
fers siempre toman un argumento longitud o cuenta.
Las rutinas de manipulacin requieren que el archivo de cabecera
<mem.h> se incluya en su programa.
memccpy #include <mem.h>
#include <string.h>
void *memccpy(void *dest, const void *s, int c, size_t n);
Copia n bytes desde s a dest hasta que n bytes han sido copiados o c
se copia a dest.
res = memccpy(buf_dest, bufen, c, 81);
Funciones relacionadas: memcpy, memmove, movedata, movmem.
memchr #include <mem.h>
#include <string.h>
void *memchr(const void *buf, int c, size_t n);
Busca un carcter especfico c en un buffer (buf) examinando los n pri-
meros caracteres.
result = memchr(direc, I, 40);
Funciones relacionadas: memcmp, memicmp.
memcmp #include <mem.h>
int memcmp(const void *b1, const void *b2, size_t n);
Compara n bytes de un buffer (b1) con los de otro buffer (b2). Devuel-
ve un valor:
< 0 si b1 < b2
= 0 si b1 = b2
> 0 si b1 > b2
resultado = memcmp(buf1, buf2, sizeof(buf1));
Funciones relacionadas: memicmp.
memcpy #include
void *memcpy(void *dest, const void *fuente, size_t n);
Copia n bytes de fuente en dest. Devuelve un puntero a dest.
memcpy(dest, fuente, 80):
Funciones relacionadas: memccpy, memmove, movedata.
memicmp #include <mem.h>
#include <string.h>
int memicmp (const void *b1, const void *b2, size_t n);
Compara un nmero de bytes de un buffer (b1) con otro (b2) sin hacer
caso del tamao de las letras en los dos buffers.
if(memicmp(buf1, buf2, 15) == 0)
puts(Los buffers son iguales en los 15 primeros bytes \n);
Funciones relacionadas: memcmp.
memmove #include <string.h>
#include <mem.h>
void *memmove(void *dest, const void *f, size_t n);
Mueve n bytes de un buffer (f) a otro (dest).
Funciones relacionadas: memccpy, memcpy, movedata.
memset #include <string.h>
void *memset(void *s, int c, size_t n);
Fija los n primeros bytes del array s al carcter c.
resultado = memset(buffer,1, 50);
Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.
movedata #include <mem.h>
#include <string.h>
void movedata (unsigned ss, unsigned so,
unsigned ds, unsigned do, size_t n);
Mueve n bytes desde ss a ds, donde ss es el segmento fuente, so es el
desplazamiento fuente, ds es el segmento destino, do es el desplazamiento
destino y n es el nmero de bytes que hay que mover.
movedata(seg1, off, seg2, dest_off, 4096);
Funciones relacionadas: memcpy, memmove, movmem, segread.
movmem #include <mem.h>
void movmem(void *fuente, void *destino, unsigned n);
Copia n bytes de fuente a destino.
movmem(&fuente[6], fuente, sizeof(fuente));
Funciones relacionadas: memmove.
setmem #include <mem.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);
Funciones relacionadas: memset.
swab #include <stdlib.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
Funciones relacionadas: Slo est disponible en sistemas UNIX.
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 atribu-
tos de texto (tales como subrayado, vdeo inverso, parpadeo, colores de
fondo y primer plano), as como actuar sobre ventanas de texto. Estas fun-
ciones se encuentran esencialmente en el archivo de cabecera conio.h.
clreol #include <conio.h>
void clreol(void);
Borra la lnea actual desde la posicin del cursor al final de la lnea.
clreol()
Funciones relacionadas: clrscr, delline, textbackground, window.
clrscr #include <conio.h>
void (clrscr(void);
Borra la ventana actual y pone el cursor en la esquina superior izquier-
da (1,1).
clrscr();
Funciones relacionadas: clreol, textbackground, window.
delline #include <conio.h>
void delline(void);
Borra la lnea completa que contiene el cursor y desplaza hacia arriba
las lneas que haya debajo.
delline();
Funciones relacionadas: clreol, clrscr.
gettext #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 abso-
lutas.
if(!gettext(1,1,30,20, pan_grabada))
puts(color);
Funciones relacionadas: movetext, puttext.
gettextinfo #include <conio.h>
void gettextinfo(struct text_info *r);
Devuelve informacin relativa a las coordenadas de la ventana actual,
posicin del cursor dentro de la ventana, atributo del texto, las dimensiones
de la pantalla y el modo de texto actual. La informacin se devuelve en una
estructura text_info.
struct text_info {
unsigned char winleft; // coordenadas x, y esquina superior
// izquierda
unsigned char wintop; // ventana actual
unsigned char winright; // coordenadas x, y esquina inferior
// derecha
unsigned char winbottom; // ventana actual
unsigned char attribute; // atributo texto actual
unsigned char normattr; // atributo texto normal
unsigned char currmode; // modo texto actual
unsigned char screenheight;// altura de la pantalla
unsigned char screenwidth; // anchura pantalla
unsigned char curx; // coordenada x cursor
unsigned char cury; // coordenada y cursor
};
gotoxy #include <conio.h>
void gotoxy(int x, int y);
Mueve el cursor a una posicin especificada (columna x, fila y) dentro
de la ventana de texto actual.
gotoxy(15, 4);
Funciones relacionadas: wherex, wherey, window.
highvideo #include <conio.h>
void highvideo(void);
Activa caracteres de alta intensidad.
highvideo();
Funciones relacionadas: lowvideo, normvideo, textcolor.
insline #include <conio.h>
void insline(void);
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 #include <conio.h>
void lowvideo(void);
Activa los caracteres a baja intensidad.
lowvideo();
Funciones relacionadas: highvideo, normvideo, textcolor.
movetext #include <conio.h>
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: gettext, puttext.
normvideo #include <conio.h>
void normvideo(void);
Reinicializa los atributos de texto al valor que tenan antes de que arran-
que el programa.
normvideo();
Funciones relacionadas: highvideo, lowvideo, textattr, textco-
lor.
puttext #include <conio.h>
int puttext(int izda, int arriba, int dcha, int abajo,
void *textbuf);
Copia el contenido de un buffer en una zona rectangular de la pantalla
en modo texto.
puttext(3, 1, 32, 22, buffertexto);
Funciones relacionadas: gettext, movetext.
_setcursortype #include <conio.h>
void setcursortype(int estilo_cursor);
Cambia la forma del cursor en modo texto. El argumento tiene que ser
una de las constantes.
_NOCURSOR Desactiva el cursor.
_SOLIDCURSOR Un carcter bloque slido es el cursor.
_NORMALCURSOR Un subrayado parpadeante es el cursor.
setcursortype(_SOLIDCURSOR);
Funciones relacionadas: cprintf, cputs.
textattr #include <conio.h>
void textattr(int atrib);
Fija el atributo de texto a atrib. Se utiliza para controlar la apariencia
del texto en la pantalla.
textattr(YELLOW + (RED << 4));
textattr(10110100);
Funciones relacionadas: gettextinfo, highvideo, lowvideo, norm-
video, textbackground, textcolor.
textbackground #include <conio.h>
void textbackground(int colorfondo);
Establece el color de fondo para texto vidualizado.
textbackground(2);
textcolor #include <conio.h>
void textcolor(int colorprimerplano);
Establece el color del primer plano del texto visualizado por cprintf y
cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15
WHITE (blanco).
textcolor(15);t
Funciones relacionadas: textattr, textbackground.
texmode #include <conio.h>
void textmode(int nuevomodo);
Conmuta al modo texto especificado por el argumento nuevomodo.
-1 LASTMODE ltimo modo de texto.
0 BW40 Monocromo 40 columnas.
1 C40 Color 40 columnas.
2 BW80 Monocromo 80 columnas.
3 C80 Color 80 columnas.
7 MONO Monocromo 80 columnas.
64 C4350 EGA 43 filas o VGA 50 filas.
textmode(C40);
Funciones relacionadas: gettextinfo, restorecrtmode.
wherex #include <conio.h>
wherey
int wherex(void);
int wherey(void);
Determina la coordenada x (wherex) y la coordenada y (wherey) de la
posicin del cursor en la ventana actual.
xpos = where(x); ypos = where(y);
window #include <conio.h>
void window(int izda, int arriba, int dcha, int abajo);
Define una regin rectangular de la pantalla como la ventana de texto
actual esquina superior izquierda (izda, arriba) y esquina inferior dere-
cha (dcha, abajo).
window(15, 5, 54, 14);
// ventana de 40 x 10 con origen en (15, 5)
Funciones relacionadas: gettextinfo, textmode.

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

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

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

Cargado por

Copyright:

Formatos disponibles

F.1. PlahIilla reIerehcia de ehIradas.

F.2. Fuhciohes de asighacih de memoria.

También podría gustarte