Bibliotecas Borland y c++f

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

Transcript of Bibliotecas Borland y c++f

Page 1: Bibliotecas Borland y c++f

���� ��������� � � ����� � �������

���� ������ ��� ����������� �� �����

���� ������ ��� ������ �������� ������

���� ������ ��� ���� ���

���� ������ ��� ������������� ������ � ��

���� ������ ��� ���� ������ � �!����!���"�

��#� ������ ��� ��������� ��� ������

��$� ������ ��� ��������� �%��� ����

��&� ������ ��� ����' ������ ������

���(� ������ ��� � �����)������

����� ������ ��� �� ����� ����!'���

����� ������ ���� �*����

����� ������ ��� ����%�������� ������ ��� �� ����� ���� ��"�

����� ������ ��� �%� � ������� � +��

� � � � � � � �

� � � � � � � � � � � � � � � � � � � � � � � �

� � � � � � � � � � � � � � � � � � � � � � � �

Esta parte es una revisión breve de la biblioteca de rutinas (funciones) yarchivos include, en tiempo de ejecución. La biblioteca de Borland C++ esun conjunto de más de 450 funciones y macros preparadas para utilizar ydiseñadas para su uso en programas C++. La biblioteca en tiempo de ejecu-ción hace la programación más fácil, ya que incluye una amplia variedad detareas tales como E/S de bajo y alto nivel, manipulación de cadenas y archi-vos, asignación de memoria, control de procesos, cálculos matemáticos, etc.

Las rutinas de Borland C++ están contenidas en los archivos de bibliote-ca Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ imple-menta la versión estándar última de ANSI C, que entre otras cosas recomien-da el uso de los prototipos de función en las rutinas de sus programas C++.

Este apéndice describe alfabeticamente funciones de la biblioteca Bor-land C++ y contiene todas las funciones incluidas en ANSI/ISO C++.

���� � ���� ����������������

Las entradas de las diferentes funciones y macros han sido normalizadaspara facilidad de manejo del lector. Las rutinas han sido clasificadas porcategorías (en general, se ha procurado respetar la clasificación dada porBorland y ANSI, pero con una adaptación más próxima al uso diario delprogramador /.

Al comienzo de cada categoría se hace una breve descripción de sucometido principal y se presenta una tabla con las funciones que contienecada categoría por orden alfabético, así como una breve síntesis de su des-cripción o propósito. A continuación, por orden alfabético, se describen lasrutinas de acuerdo al siguiente modelo para cada entrada.

���� ��������������������������

Borland C++ almacena información en la memoria principal de la compu-tadora por dos métodos. El primero utiliza variables globales y locales(incluyendo arrays, cadenas y estructura); en este caso, el almacenamientoo longitudes fija. Para cambiar el tamaño de arrays y cadenas de caracteresse debe editar el archivo fuente y recompilar su programa. Esta informaciónse almacena en la pila (stack). El segundo método de almacenar informa-ción es asignar memoria a medida que el programa lo requiera y liberar estamemoria cuando ya no se necesita; esta acción permite utilizar la misma

,-./0.12-

nombre función archivo de cabecera

• strrev #include <string.h>

char *strrev(char *cad) sintaxis

DescripciónPropósito y breve descripción de cómo y dónde se utiliza la función.

EjemploUna o más instrucciones o programas sencillos, donde se muestra la explicaciónreal de la función.

Funciones relacionadas: strcpy, strncpy.Funciones relacionadas con la función descrita.

Page 2: Bibliotecas Borland y c++f

memoria para colas diferentes en un tiempo distinto. Este proceso de asig-nar memoria se denomina asignación dinámica de memoria.

Por omisión, cada vez que se ejecuta un programa, DOS establece unsegmento de 64 Kb denominado segmento de código, que contiene su códi-go programa. DOS establece también un segmento de 64 Kb denominadosegmento de datos. Su programa puede tener múltiples segmentos de datosy códigos.

El segmento de datos se divide en tres regiones: datos del programa(variables estáticas y globales), pila —stack— (variables locales y argu-mentos) y montón o montículo —heap.

�������������

Después de asignar partes del segmento de datos a variables estáticas yglobales y a la pila, el compilador dedica el resto del segmento de datos almontículo o heap.

Borland C++ contiene un gran número de funciones para asignacióndinámica de memoria, que realizan una gran variedad de tareas: asignar yliberar memoria del montículo y de la pila, obtener información de bloquesde memoria, etc.

allocmen #include <dos.h>

int allocmen(unsigned t, unsigned * seg);

La función allocmen() establece seg para apuntar a un segmento asig-nado de memoria de t párrafos (1 párrafo = 16 bytes) de largo. Si hay éxitose devuelve –1, si hay error (falta memoria), allocmen() devuelve eltamaño en párrafos del mayor bloque disponible.

if(allocmen(size, &segadd)!= -1)printf (“Error asignación memoria \n”);

Funciones relacionadas: falloc frremem, malloc, setblock.

brk #include <alloc.h>

int brk( void* a)

La función brk permite modificar el «valor break» de un programa. Elvalor break es la dirección de la primera posición más allá del segmento de

Montículo Pila Datos del programa(heap) (stack)

datos de un programa. Si hay éxito se devuelve 0; en caso contrario, –1, y lavariable 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 tamaño n.s). El bloque seborra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debeutilizar farcalloc. Devuelve un puntero al bloque recién asignado. Si noexiste bastante espacio para el nuevo bloque o bien n o s es 0, callocdevuelve nulo.

long *bufferbuffer=(long *) calloc(40, sizeof(long));

Funciones relacionadas free, malloc.

coreleft #include <alloc.h>

unsigned coreleft(void) // modelos small, tiny, mediumunsigned long coreleft(void); // en otros modelos de memoria

Determina la cantidad de memoria no utilizada. El valor devueltodepende 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 función asigna n piezas de tamaño s y las pone a 0. Un puntero alprincipio de la memoria asignada se devuelve si farcalloc() tiene éxito;en caso contrario se devuelve NULL.

��� ������������������ �������� �������������!���

Page 3: Bibliotecas Borland y c++f

if(array_grande=farcalloc(20000L, sizeof (int)) “” NULL)printf (“Fallo en asignación de memoria\n”);

Funciones relacionadas: calloc, farfree, farmalloc, malloc.

farcoreleft #include <alloc.h>

unsigned long farcoreleft(void);

Determina el número 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 montículo (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 montículo (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 montículo (heap) far.

estadoheap = farheapchecknode(arraygrande);

farheapfillfree #include <alloc.h>

int farheapfillfree(unsigned int f);

Rellena todos los bloques libres del montículo 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 información sobre las entradas en el montículo (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 memoriaencima de la pila está disponible para asignación por farmalloc. El tamañodel bloque puede exceder de 64 Kb.

if(bloquegrande = farmalloc(80000L) == NULLprintf(“Asignación fallada\n”);

Funciones relacionadas: calloc, farfree, farcalloc, malloc.

��� ������������������������������������ ��������� ��"

Page 4: Bibliotecas Borland y c++f

farrealloc #include <alloc.h>

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

Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b,al cual se ha asignado una longitud de n bytes).

if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL printf(“Fallo reasignación memoria\n”);

Funciones relacionadas: calloc, farcalloc, farfree, malloc.

free #include<alloc.h>#include <stdlib.h>

vid free(void *dir_memoria);

La función free() libera un bloque de memoria. El argumentodir_memoria apunta a un bloque de memoria previamente asignado através de una llamada a calloc, malloc o realloc. Después de la llama-da el bloque libre está disponible para asignación.

char *cad;// asignar memoria para cadenacad = (char *) malloc(50);

...free(cad); // liberar memoria

Funciones relacionadas: calloc, malloc, realloc

heapcheck #include <alloc.h>

int heapcheck(void);

Verifica la consistencia del montículo (heap). En Visual C++ 6.0 la fun-ción 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 montículo (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). Verificael 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 elmontículo con un valor de carácter especificado. En Visual C++ la funciónequivalente 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 información sobre las entradas en el montículo(heap). La función equivalente en Visual C++ es _heapwalk.

��# ������������������ �������� �������������!���

Page 5: Bibliotecas Borland y c++f

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 montículo. Devuelve un puntero, quees la dirección 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 tamaño de un bloque de memoria b asignado por malloc ocalloc a un tamaño de n bytes. Devuelve un puntero void al bloque dememoria 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 valorbreak es la dirección del primer byte disponible en el segmento de datos poromisión, más allá del segmento de datos que está siendo utilizado por losdatos en el proceso.

sbr(500);

Funciones relacionadas: brk, coreleft

setblock #include <alloc.h>

int setblock(unsigned seg, unsigned n);

Ajusta el tamaño de un bloque de memoria asignado anteriormente porallocmen. Esta función llama a la función 4Ah de DOS para ampliar eltamaño de un bloque de memoria previamente asignado por allocmen. Enlas versiones Visual C++ la función equivalente es _dos_setblock.

��$� ����������%�&�������������

La mayoría de los programas requieren casi siempre alguna operación declasificación y búsqueda 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 función bsearch realiza una búsqueda binaria en un array ordena-do b, de n elementos, cada uno de a bytes de tamaño. El argumento k apun-ta al valor que se está buscando. bearch devuelve un puntero (la dirección)a la primera aparición del valor k en el array. Si no se encuentra el valor,bsearch devuelve o.

El argumento comparar proporciona la dirección de una rutina queaceptará dos argumentos elem1 y elem2, cada uno un puntero a un elemen-to del array. La función comparar compara cada uno de los elementos apun-tados y devuelve un valor de acuerdo con la tabla siguiente:

Valor devuelto Condición

Negativo Primer elemento menor que el segundo (elem1) (elem2).

Cero Los dos elementos son idénticos.

Positivo Primer elemento mayor que el segundo.

La búsqueda binaria requiere que el array esté ordenado, por lo cual,caso de que no esté ordenado el array, se puede utilizar la función qsortpara ordenar el array antes de llamar a bsearch.

Funciones relacionadas: lfind, lsearch, qsort.

��� ������������������������������������ ��������� ��'

Page 6: Bibliotecas Borland y c++f

lfind #include <stdlib.h>

void * lfind(const void k, const void *b, size_t *num, size_tanchura, int(*comparar)(const void*, const void*));

La función lfind() realiza una búsqueda lineal de valor de k (clave) enun array de un número específico de elementos, cada uno de un número fijode bytes de longitud. Al contrario que bsearch(), el array no necesitaestar ordenado. lfind() devuelve un puntero al primer elemento del arrayque 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 función lsearch realiza una búsqueda lineal de la clave k. Elarray a contiene n elementos de anchura W. La función comparar se uti-liza para comparar la clave con el elemento actual del array. Al contrarioque bsearch(), en la función lsearch() el array no tiene que estarordenado. lsearch() devuelve un puntero al primer elemento del arrayque se corresponde con la clave. Si no existe la clave en el array, sedevuelve 0 y un registro se añade al array con un valor de k.

La diferencia entre lsearch() y lfind() es que lsearch() añadiráun registro al final del array con un valor de la clave si ese registro no se haencontrado 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 función qsort ordena un array con un número dado de elementosutilizando el método de ordenación rápida quicksort (creado por C.A.R.Hoare). El número de elementos de array es n y el tamaño (en bytes) de cadaelemento es w. La función comparar se utiliza para comparar un elementodel array con la clave; devuelve los siguientes valores:

Valor devuelto Condición

Negativo Primer elemento (elem1) menor que el segundo (elem2).

Cero Los dos elementos son idénticos.

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 enteroscomparar(const void *i, const void *j){

return ((int *)i) – ((int *) j)}

Funciones relacionadas: bsearch, lfind, lsearch.

��(� ��������������

C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratancomo arrays de caracteres, cada uno de los cuales ocupa un byte. Por notaciónel final de una cadena en C se representa por un byte que contiene un carácternulo (´\0´). Las cadenas pueden ser declaradas como arrays de caracteres.

char cad[20], cad 5[] = “Hola Mortimer”;

��� ������������������ �������� �������������!���

Page 7: Bibliotecas Borland y c++f

���������������

A las cadenas se accede directamente a través de su índice, como en elejemplo anterior, o bien a través de un puntero.

char cad5[] = “Hola Mortimer”;char *p_cad5;p_cad5 = cad5;

Se puede también declarar e inicializar una cadena a la vez:

char *p_cad5 = “Hola Mortimer”;

El archivo de cabecera <string.h> contiene numerosas funciones quemanipulan cadenas.

stpcpy #include <string.h>

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

La función stpcpy() copia una cadena en otra. Devuelve un puntero alfinal 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 (añade) cad1 al final de cad2, terminando la cade-na resultante con un carácter nulo (\0).

char nombre[80] = “Bob”;char blanco[2] = “”;char ultimo[80] = “Marley”;...strcat(nombre,blanco); // blanco se concatena a nombrestrcat(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 aparición de c en cad y devuelve unpuntero a la primera aparición de c en cad. Si c no se encuentra, devuelveun cero (NULL).

printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));

visualizará $85725

char *s[81] = “Esta es una cadena de prueba”;char *ptr;ptr = strchr(s, ´a´);

el valor almacenado en ptr es un puntero a la primera aparición de ´a´.

strcmp #include <string.h>

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

Compara una cadena con otra. Los resultados serían:

> 0 si a > b= 0 si a == b< 0 si a < b

i = strcmp(“MNP”, “mnp”); // resultado < 0i = strcmp(“abc”, “abc”); // resultado = 0i = 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 mayúsculas y minús-culas y devuelve un entero:

��� ������������������������������������ ��������� ���

Page 8: Bibliotecas Borland y c++f

< 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 resultanteexcede el tamaño 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 posición de la primera aparición en una cadena de cualquiercarácter de otra cadena. Si tiene éxito, la función strcspn devuelve el índi-

ce del primer carácter de cad1, que pertenece al conjunto de caracteres decad2.

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 acad. Si falla la asignación de memoria, strdup() devuelve un carácter 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 número dadoen el argumento errnum. La función strerror() obtiene el mensaje deerror del sistema utilizando el valor en la variable global errno, como elíndice una tabla de errores denominadas sys_errlist, que está declaradoen el archivo de cabecera stdlib.h.

errno = 0;printf (“Error”, strerror(errno);

Funciones relacionadas: perror, _strerror.

��� ������������������ �������� �������������!���

Page 9: Bibliotecas Borland y c++f

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

char *strerror(const char *cad);

Esta función sirve para generar un mensaje de error definido por elusuario.

printf(“%S”, _strerror(“error apertura archivo”));

Funciones relacionadas: perror, strerror.

stricmp #include <string.h>

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

Esta función se utiliza para comparar una cadena a otra sin tener encuenta el tamaño de las letras. Convierte todos los caracteres alfabéticos decad1 y cad2 en minúsculas; a continuación, se comparan las dos cadenas ydevuelve un valor entero que indica el orden lexicográfico de cad1 con res-pecto a cad2.

Si cad1 = cad2 el valor de la función es cero.Si cad1 < cad2 el valor de la función es menor que cero.Si cad1 > cad2 el valor de la función es mayor que cero.

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 carácter nulo no se inclu-ye en la longitud; en consecuencia, cuando reserve espacio, recuerde añadir1 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 minúsculas. La función devuelve unpuntero 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 función strncat() añade los primeros n caracteres de cad2 a cad1,y termina la cadena resultante un carácter nulo. Si cad2 es mayor que ncaracteres de longitud, strncat() truncará la cadena a la longitud de n. Enotro 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 número especificado en caracteres de dos cadenas ydevuelve 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)

��� ������������������������������������ ��������� ��$

Page 10: Bibliotecas Borland y c++f

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 otrocarácter). Devuelve un puntero a la cadena cad. El carácter c se utiliza pararellenar la cadena con ese carácter; n es el número de posiciones de carac-teres que se han de inicializar.

printf(“Introduzca una cadena:”);gets(cadena);printf(“Introducir un carácter:”);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 aparición en cad1 de cualquiera de los caracteresde cad2. El carácter nulo no se incluye en la búsqueda. Si el carácter noexiste, se devuelve un carácter 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 aparición del carácter c en cad. Devuelve un pun-teo a la última aparición de c o un carácter 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 carácter de terminación nulopermanece en el mismo lugar. strrev() devuelve un puntero a la cadenainversa.

Aplicación: Invertir una cadena leída del teclado e imprimir el resultado.

#include <stdio.h>#include <string.h>main(){

char demo[80]printf(“Introduzca una cadena:”);gets(demo);strrev(demo);printf(“La cadena inversa es:\n %s |\n”, demo);return 0;

}

Funciones relacionadas: strcpy, strncpy.

strset #include <string.h>

char *strset(char *cad, int c);

Establece todos los caracteres de la cadena cad al valor de c. Terminacuando se encuentra el primer carácter nulo. Devuelve un puntero a la cade-na modificada.

char *cad = “-----”;strset (cad, ´x´); // cad es ahora xxxxx

Funciones relacionadas: strnset.

��( ������������������ �������� �������������!���

Page 11: Bibliotecas Borland y c++f

strspn #include <string.h>

sze_t strspn(const char *cad1, constchar *cad2);

Localiza la posición del primer carácter de una cadena (cad1) que nopertenece 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 aparición de una cadena en otra. Si tiene éxito, lafunción strstr devuelve un puntero a la primera aparición de cad2 comouna subcadena de cad1. Si la búsqueda 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 sealcanza 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 minúscula de la cadena en mayúscula ydevuelve un puntero a la cadena convertida (sólo alfabeto inglés).

La función strupr y su homónima strlwr no forman parte de la 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 información específica local y conun número máximo de caracteres a situar en cad1 de n. En el siguienteejemplo, strxfrm transforma los tres primeros caracteres de cad1 en lostres primeros caracteres de cad2.

char *cad1 = “abcdefg”;char *cad2 = “1234567”;

clrscr();strxfrm(cad1, cad2, 3);printf(“Transformada: %s\n”, cad1);

���� ���������� �����������

���������

C utiliza el conjunto de caracteres ASCII. Con frecuencia se necesita deter-minar la categoría de un carácter o convertir un carácter de mayúsculas enminúsculas, o viceversa. La biblioteca C contiene funciones que pueden serdefinidas como macros para estos propósitos. Las macros están definidas enel archivo de cabecera ctype.h.

Las macros de clasificación sirven para determinar qué clase de valorcontiene una variable carácter. Puede necesitar conocer esta característicapara identificar ciertas clases de caracteres. Por ejemplo, si su programapide al usuario que teclee un número, pero el usuario teclea —en su lugar—una letra, será preciso capturar el error. Otro caso es cuando desea imprimirun archivo, y necesita asegurarse de que el archivo contiene sólo caracteresimprimibles, en caso de que desee que su programa acepte caracteres decontrol, necesita saber cuándo pulsa el usuario un carácter de control. Enresumen, cada vez que necesite identificar el tipo de tecla que ha pulsado elusuario, se pueden utilizar las macros de clasificación.

��� ������������������������������������ ��������� ���

Page 12: Bibliotecas Borland y c++f

Asimismo, existen otras funciones en el archivo ctype.h que sirvenpara convertir caracteres en mayúsculas en minúsculas, y viceversa; y valo-res enteros en códigos ASCII.

isalnum #include <ctype.h>

int isalnum(int c);

La función isalnum() devuelve un cero si c es un carácter no alfa-numérico y un valor distinto de cero si el carácter es alfanumérico.

carac = getch();if(isalnum(carac))

printf(“%c letra|digito \n”, carac);else

printf(“%c no letra|digito \n”, carac);

Funciones relacionadas: isascii.

isalpha #include <ctype.h>

int isalpha(int c);

La función isalpha() verifica si un carácter es alfabético. Devuelve unvalor distinto de cero si c es un carácter alfabético, o 0 si c no es alfabético.

int c = getah()if(isalpha©) printf(“%c es letra\n”, c);

Funciones relacionadas: iascii.

isascii #include ctype.h>

int isascii(int c);

Comprueba si un carácter c es un carácter ASCII; c está en el rango 0-127.Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII.

carac = getch();if(isascii(carac))

printf(“%c es ASCII \n”, carac);else

printf(“%c no es ASCII \n”, carac);

Funciones relacionadas: toascii, isalnum, isdigit,

iscntrl, isdigit #include <ctype.h>isgraph, islowerisprint, ispunct, isspaceisupper,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 específicas de uncarácter ASCII.

Macro Verifica Rango válido de valores

iscntrl Carácter de control. 0..1Fh, 7Fh

isdigit Dígito decimal. ´0´..´9´

isgraph Carácter imprimible (sin espacio). 21h a 7Eh

islower Carácter minúscula. ´a´..´z´´

isprint Carácter imprimible 20h..7Eh

ispunct Carácter puntuación 21h..2Fh, 3Ah..40h,

5Bh..60h, 7Bh..7Eh

isspace Carácter blanco. 9h..Dh 0 20h (blanco)

isupper Carácter mayúscula. ´A´..´Z´

isxdigit Dígito hexadecimal. ´0´..´9´

´A´..´F´

´a´.. f´

Cada macro (función) devuelve un valor distinto de cero si c satisfaceel criterio de esa macro; en caso contrario, devuelve un cero.

if(isprint(c)) printf(“\n %c imprimible\n”, c);if(iscntrl(c)) printf(“%c es un carácter de control\”, c);if(isdigit(c)) printf(“%c es un dígito\n”, c);if(islower(c)) printf(“%c es letra minúscula\n”, c)

Funciones relacionadas: iascii.

��� ������������������ �������� �������������!���

Page 13: Bibliotecas Borland y c++f

toascii #include <ctype.h>

int toascii(int c);

Esta función convierte un valor entero en un carácter ASCII válido.

C = toascii(entero);

Funciones relacionadas: iascii.

_tolowertolower #include <ctype.h>

int _tolower(int c);int tolower(int c);

Convierte un carácter mayúscula en minúscula. Utilice _tolower sólocuando esté seguro de que el carácter que quiere convertir es una letramayúscula.

La función _tolower() sólo está disponible en sistemas UNIX. Porconsiguiente, para asegurar la compatibilidad utilice sólo la función tolo-wer().

c = tolower(´S´); // c se convierte en ´S´

Funciones relacionadas: iascii, _toupper, toupper.

_touppertouper #include <ctype.h>

int _toupper(int c);int _toupper(int c);int c; // carácter a convertir

Estas funciones convierten un carácter minúscula en mayúscula. Utili-ce _toupper sólo cuando esté seguro de que el carácter que quiere conver-tir es una letra minúscula (rango a-z).

La macro _toupper no está disponible en ANSI C. Para asegurar lacompatibilidad, utilice siempre toupper().

c = toupper(´S´); // c se convierte en ´S´

Funciones relacionadas: iascii, _tolower, tolower.

���� ����������� ������)��*��*���+

Las funciones de calendario (fecha y hora) permiten obtener la hora actualy, a continuación, convertirla y almacenarla de acuerdo a sus necesidadesparticulares. La hora actual se toma siempre de la hora del sistema. Las fun-ciones de calendario están incluidas en el archivo de cabecera time.h.

asctime #include <time.h>

char *asctime(const struct tm *hora);

Convierte la fecha y la hora almacenada en una estructura de tipo tm enuna cadena de caracteres. La estructura tm se define en time.h así:

struct tm{

int tm_sec; // [0,59], segundosint tm_min; // [0,59], minutosint tm_hour; // [0,23], horasint tm_mday; // [1,31], dias del mesint tm_mon; // [0,11], mes del añoint tm_year; // [desde 1900], añoint tm_wday; // [0,6], dias desde domingoint tm_yday; // [0,265], numero dia añoint 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 dividirsepor 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.

��� ������������������������������������ ��������� ��"

Page 14: Bibliotecas Borland y c++f

ctime #include <time.h>

char *ctime(const time_t *hora);

Convierte la fecha y hora almacenada como valor de tipo time_t en unacadena de caracteres (mes día hora año\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, finclrscrl();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) enformato 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 apuntadapor ptrhora.

struct timeb {long time; // segundos desde 00:00:00 hora GMTshort millitm; // milisegundosshort timezone; // diferencia en minutos

// hora Greenwich y hora localshort 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 laestructura date definida en dos.h.

struct date {int da_year; // año actual (1980-2099)char da_day; // dia mes (1-31)char da_mon; // mes (1-12)};

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)

��# ������������������ �������� �������������!���

Page 15: Bibliotecas Borland y c++f

unsigned char ti_hour // horas (0-23)unsigned char ti_hund // centésimas 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)(año, mes, día, hora, minutos, segundos y otros campos). Véase struct tmen 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 tipotm. Véase 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. Véase struct tm enasctime.

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 (día,mes. Año) se especifican en los campos de la estructura date.

struct date {int da_year; // año actualchar da_day; // día meschar da_mon; // mes, 1 para enero, 2...

};

En Visual C++ la función equivalente es _dos_setdate.

setdate(&fecha);

Funciones relacionadas: getdate, gettime, settime, dostounix.

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 laestructura time definida en dos.h. Véase 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 posicióncuya dirección está en el argumento t.

time_t horasis;horasis = time(NULL);stime(&horasis);printf(“segundos desde 1/1/70 %ld”, horasis);

Funciones relacionadas: dostounix.

��� ������������������������������������ ��������� ��'

Page 16: Bibliotecas Borland y c++f

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 unalongitud máxima 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 de1/1/1970 tiempo GMT.

time(&hora);

tzset #include <time.h>

void tzset(void);

Establece las variables de entorno horarios TZ; asigna valores a lasvariables 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.

��"� ��������������� �����������

MS-DOS, al igual que UNIX, utiliza un sistema de archivos jerárquico quepermite al usuario organizar sus archivos en directorios y subdirectorios.Las funciones de control de directorios en Borland C++ proporcionan lasherramientas necesarias para crear, modificar, mover y eliminar directoriosdesde sus programas C. Las funciones de manipulación 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 elargumento camino. La función devuelve un 0 si tiene éxito; en caso contra-rio, devuelve un valor de –1 para asignar el error. Cuando se produce unerror, la variable global errno toma el valor ENOENT (camino o archivo noencontrado).

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 cuyonombre 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

�$� ������������������ �������� �������������!���

Page 17: Bibliotecas Borland y c++f

char ff_atrib; // encontrado atributoint ff_ftime; // hora archivoint ff_date; // fecha archivolong ff_fsize; // tamaño archivochar ff_name[13]; // encontrado nombre de archivo

};

La variable attrib viene definida en el archivo de cabecera <dos.h> ypuede ser igual a uno de estos valores:

FA_RDONLY Archivo de sólo 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 continúa la búsqueda de findfirst(). findnext llama ala función 4Fh de DOS para encontrar el siguiente archivo cuyo nombre yatributos son idénticos a los dados en la llamada a la función 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) yextensión 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 launidad (u), camino del directorio, nombre del archivo y extensión 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 específica. Elnúmero de la unidad (u) 0 indica la unidad actual por omisión, 1 significaunidad A, 2 unidad B, etc. La función devuelve un cero si tiene éxito, encaso 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 indicaa getcwd el máximo número de caracteres que el buffer camino puede con-tener. La función getcwd es útil para obtener el nombre del directorio actualy guardarlo. Si su programa cambia los directorios de trabajo durante su eje-cución, puede utilizar el nombre guardado para restaurar el directorio de tra-bajo actual antes de terminar.

getcwd(cuentas, 80)

Funciones relacionadas: chdir.

��� ������������������������������������ ��������� �$�

Page 18: Bibliotecas Borland y c++f

getdisk #include <dir.h>

int getdisk(void);

La función getdisk obtiene el valor entero que representa la unidadactual (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 eldirectorio esté vacío, no sea el directorio raíz y no sea el directorio de tra-bajo rmdir(); devuelve 0 si la operación de borrado tiene éxito; si se pro-duce un error, el valor devuelto es –1 y la variable global errno se fija a unode los siguientes valores:

EACCES Permiso denegado.ENOENT Camino archivo no encontrado.

Esta función es similar a RMDIR o RD de MS-DOS.

rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS

Funciones relacionadas: chdir, mkdir.

mkdir #include <dir.h>

int mkdir(const char *camino);

Crea un directorio con un nombre de camino especificado. Funcionaigual 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 globalerrno toma el valor EACCES (permiso denegado) o ENOENT (nombre decamino no válido).

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 específico en una lista de directorios, incluyendo eldirectorio 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 delarchivo; en caso contrario, se devuelve NULL.

buffer = searchpath(“BC.EXE”);

Localizar el archivo AUTOEXEC.BAT en los directorios definidos en lavariable 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 omisión. El valor de la unidad (unidad)es un entero.

Unidad AB:C:D:...nuevaunidad = setdisk(3); / nueva unidad actual es C:

Funciones relacionadas: getdisk

�$� ������������������ �������� �������������!���

Page 19: Bibliotecas Borland y c++f

��#� ��������������� ��������

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 elsistema operativo. Consta del código del programa y de datos, además deinformación relativa al proceso, tales como número 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 mayoría de las funcionesde control se declaran en el archivo de cabecera process.h; otros archivosde cabecera que contienen funciones de control de proceso y del entorno sonlocale.h, signal.h, setjmp.h y stdlib.h.

abort #include <process.h>#include <stdlib.h>

void abort(void);

Termina la ejecución del programa actual y devuelve un código de error (3).

if (argc 1) {printf(“Faltan argumentos!\n”)abort()

}

Funciones relacionadas : exit, _exit, raise, signal, spaw.

assert #include <assert.h>

void assert(int expresión);

Imprime un mensaje de error e interrumpe el programa siexpresión esfalsa (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 función 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 ocupadapor su código del programa. Las funciones exec crean un proceso hijo quecarga 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 través del buffer y se llama a cualquier función exitregistrada. estado representa el estado de salida del programa; 0, salidanormal; distinto de cero, indica un error.

exit(0);

��� ������������������������������������ ��������� �$$

Page 20: Bibliotecas Borland y c++f

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 operacionesauxiliares (como cierre de archivos).

_exit(0)

Funciones relacionadas: exit.

getenv #include <stdlib.h>

char *getenv(const char *nomvar);

Obtiene la definición de una variable de la tabla de entorno del proce-so. Utiliza la variable global environ para localizar la lista de las variablesde entorno y, a continuación, busca una entrada en la lista correspondientea 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 sistemasUNIX.

printf(“PID:%X\n”,getpid());

Funciones relacionadas: getpsp.

localeconv #include <locale.h>

struct lconv *localeconv(void);

Obtiene información detallada sobre formatos monetarios y numéricosde diferentes países.

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 ejecución local anteriormente grabadaen 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 continuación,el mensaje de error correspondiente al valor actual de la variable globalerrno y, finalmente, un carácter de nueva línea. Si cadena es un punteronulo o un puntero a una cadena nula, perror imprime sólo el mensaje deerror 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 variablesde entorno existentes.

if(putenv(argv[1] == -1)

Funciones relacionadas: getenv.

�$( ������������������ �������� �������������!���

Page 21: Bibliotecas Borland y c++f

raise #include <signal.h>

int raise(int señal);

Envía una señal al programa en ejecución. Crea una condición deexcepción correspondiente al número señal. Existen diferentes constantes,por ejemplo, SIGABRT (terminación anormal).

printf(“prueba de raise\n”);raise(SIGABRT);

Funciones relacionadas: abort, signal.

setjmp #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 función. Este entorno puede ser restaurado por una llamada alongjmp, 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 señales de interrupción. La función signal per-mite a un proceso elegir uno de los diferentes modos de manipular una señalde interrupción 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.

��'� ������������,�����������

Las funciones de conversión de tipos de datos sirven para crear un puente deunión entre los dos estilos de representación de números: la cadena de textolegible por los humanos y el formato binario legible por las máquinas. Lasfunciones de conversión son ideales para convertir argumentos de líneas deórdenes de su representación de cadena al formato interno.

atof() #include <math.h>#include <stdlib.h>

double atof(const char *cadena);

La función atof() convierte el argumento cadena en un valor de dobleprecisión. La cadena debe tener el siguiente formato:

[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]

opcional e/E

blancos o dígitos decimalestabulaciones

La conversión termina cuando aparece el primer carácter no reconoci-ble o cuando se encuentra un carácter nulo (´\0´).

��� ������������������������������������ ��������� �$�

Page 22: Bibliotecas Borland y c++f

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 función atoi() convierte el argumento cadena en un valor entero.La cadena debe tener el siguiente formato:

[espacio en blanco][signo][ddd]

opcional

espacio o tabulación dígitos decimales

La conversión termina cuando se encuentra un carácter no reconocible(carácter nulo, ‘\0’, punto decimal o una letra). Si no puede convertir lacadena 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 debetener el formato:

[espacio en blanco][signo][ddd]

opcional

blancos y tabulaciones dígitos decimales

La conversión de caracteres de la cadena hasta que se encuentre el pri-mer carácter no reconocible o el carácter nulo (‘\0’).

long int i;char cad_ent = “9876543”;...i = atol(cad_ent); // convierte cadena “9876543” a entero

// largo.

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 función ecvt() convierte un argumento de valor doble precisión enuna cadena con n dígitos. Si valor tiene más de n dígitos, los dígitos infe-riores se truncan. dec es un puntero a un entero en donde se devuelve laposición del punto decimal; signo es un puntero a un entero donde sedevuelve 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 función ecvt, fcvt convierte el argumento valor dedoble precisión en una cadena de n dígitos. Si el número de dígitos de valorexcede a n, el exceso de dígitos se trunca. Si hay menos dígitos que n lacadena se rellena con ceros. fcvt se diferencia de ecvt en el modo de tra-tar los dígitos significativos. ecvt() busca un número total de dígitos,mientras que fcvt() busca el número de dígitos a la derecha del punterodecimal.

cadena = fcvt(valor, exactitud, %oposición_d, &signo);

Funciones relacionadas: atof, ecvt, gcvt, itoa, ltoa, printf,sprintf, ultoa.

�$� ������������������ �������� �������������!���

Page 23: Bibliotecas Borland y c++f

gcvt #include <stdlib.h>

char *gcvt(double valor, int ndig, char, *buf);

La función gcvt() convierte el argumento valor de doble precisión enuna cadena de caracteres que se almacena en el buffer cuya dirección se daen el argumento buf. Se debe asignar bastante espacio en el buffer para con-tener todos los dígitos de la cadena convertida y el carácter nulo de termi-nación (‘\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 función itoa() convierte el argumento entero valor en una cadenade caracteres utilizando el argumento base, como base de un sistema denumeración (2 a 36). Debe existir bastante espacio en cad para contener 17caracteres, 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 función ltoa() convierte el argumento entero largo valor en unacadena de caracteres que utiliza el argumento base como base de un siste-ma de numeración. Como un entero largo ocupa 32 bits en base 2, la cade-na puede ocupar 33 bytes con el carácter nulo de terminación. Debe haberbastante espacio para contener 33 bytes. ltoa() devuelve un puntero a cad.

long valor = 99288377Lltoa(valor, cadena, 30);

Funciones relacionadas: atoi, atol, itoa, ultoa.

strtod #include stdlib.h>

double strtod(const char *cad, char **p);

La función strtod() convierte la cadena cad en un valor de dobleprecisión. La cadena debe tener el formato

[blanco][signo][ddd][.][exponente][signo][ddd]

+, - d, D, e, E

blanco/ dígitos decimalestabulación

strtod() devuelve el valor de doble precisión y cero si no se produce laconversión. La conversión se termina con el primer carácter no reconocible.

Aplicación: Convertir la cadena “843899.567” a un valor de coma flo-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 función strtol() convierte una cadena cad en un valor entero largo.La cadena (puede contener hasta 33 caracteres) debe tener el formato:

[espacio en blanco][signo][0][x|X][ddd]

+, - dígitos decimaleshexadecimal

blancos y tabulaciones octal

��� ������������������������������������ ��������� �$"

Page 24: Bibliotecas Borland y c++f

La conversión se termina con el primer carácter no reconocible. Si seproduce un error de desbordamiento (positivo o negativo) la variable errnose establece al valor de la macro ERANGE.

Aplicación. 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 labase dada. La cadena debe tener el formato:

[espacio en blanco][0][x|X][ddd]

dígitos decimalesoctal

blanco o tabulaciones hexadecimal

Si la base b es cero, strtoul utiliza el primer carácter de la cadena paradeterminar la base del valor.

La cadena cad puede contener hasta 33 caracteres, excluyendo el carác-ter de terminación nulo (´\0,). Si se produce un error de desbordamiento,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 función ultoa() toma valor en base b (entre 2 y 36) y lo convierteen una cadena. Devuelve el puntero al principio de cad. No devuelve códi-go de error. cad puede contener hasta 33 caracteres, excluyendo el carácterde terminación nulo (´\0´).

ultoa(valor, buffer, base);

Funciones relacionadas: itoa, ltoa.

����� ������������������ ���

Las funciones de E/S (Entrada/Salida, I/O, Input/Output) permiten leer yescribir datos entre archivos y dispositivos. En C no hay estructuras dearchivos 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.

����������������)-./012+

Las funciones de E/S tratan los datos como una secuencia o flujo de carac-teres individuales. La elección adecuada de las funciones disponibles per-mite procesar datos en tamaños y formatos diferentes, desde caracteres inde-pendientes a estructuras de datos complejos. La E/S por secuencia, o flujo,también proporciona acciones de taponamiento (buffering) que mejoran sig-nificativamente el rendimiento. Para utilizar los flujos, generalmente sedebe 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.

�$# ������������������ �������� �������������!���

Page 25: Bibliotecas Borland y c++f

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 número de flujos cerradosy 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 deE/S de bajo nivel, tales como open, creat, dup y dup2); asocia unaestructura 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 (vacía) un flujo. Los buffers se limpian automáticamente cuan-do están 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 carácter de la posición actual del archivo y, a continuación,incrementa esta posición.

c = fgetc(fp)

Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc,putchar.

fgetchar #include <stdio.h>

#int fgetchar(void);

Lee un carácter 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 posición actual del archivo. fos_t es un tipo defini-do en stdio.h.

fgetpos(fp, &pos_archivo);

��� ������������������������������������ ��������� �$'

Page 26: Bibliotecas Borland y c++f

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 númeromáximo 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 unflujo.

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 deacceso.

Modo Acción

“r” Abre para lectura.“w” Abre un archivo vacío para escritura.“a” Abre para escritura al final del archivo (añadir).“r+” Abre para lectura/escritura.“w+” Abre un archivo vacío para lectura/escritura.“a+” Abre para lectura y añadir.“rb” Abre un archivo binario para lectura.“wb” Crea un archivo binario para escritura.“ab” Abre un archivo binario para añadir.“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+”)) == NULLprintf(“el archivo..no se ha abierto \n”);

Funciones relacionadas: fclose, fcloseall, fdopen, ferror,fileno, freopen, open, setmode.

flushall #include stdio.h>

int flushall(void);

Vacía (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 carácter 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);

�(� ������������������ �������� �������������!���

Page 27: Bibliotecas Borland y c++f

Escribe el carácter 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 carácter 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 [, dirección,...]);

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 posición queestá desplazada desp bytes de org.

Origen Significado

SEEK_SET Principio de archivo.SEEK_CUR Posición actual puntero archivo.SEK_END Final de archivo.

fseek(f1,OL,SEEK_SET); // ir al principio

Funciones relacionadas: ftell, rewind, fopen.

fsetpos #include <stdio.h>

int fsetpos(FILE *f, const fpos_t *p);

Establece la posición del puntero del archivo al lugar especificado porel objeto apuntado por p.

fsetpos(fp, &posarch);

Funciones relacionadas: getpos.

ftell #include <stdio.h>

long int ftell(FILE *f);

Obtiene la posición actual (puntero) del archivo asociado con el flujo f.

ftell(fichen);

Funciones relacionadas: fgetpos, fssek, tell.

��� ������������������������������������ ��������� �(�

Page 28: Bibliotecas Borland y c++f

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 número de caracteres realmente escritosque, si la función tiene éxito, es igual al número 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 carácter de un flujo de entrada dado e incremen-ta la posición 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 carácter 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 carácter 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 carácter del teclado haciendo eco del carácter en la pantalla.

resp= getche();

Funciones relacionadas: cgets, getch, getchar, ungetch.

gets #include <stdio.h>

char *gets(char *cad);

Lee una línea desde el archivo de entrada estándar stdin, por omisiónes 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.

�(� ������������������ �������� �������������!���

Page 29: Bibliotecas Borland y c++f

printf #include <stdio.h>

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

Escribe cadenas de caracteres y valores de variables, con formato, en elarchivo de salida estándar stdout (por omisión, la pantalla).

Código Formato

%c Carácter.%d Entero decimal.%e Real (double o float), notación científica.%f Coma flotante.%s Cadena de caracteres.%x Hexadecimal sin signo.

printf(“producto %d y %d es %d\n”,x,y, x*y);

Funciones relacionadas: fprintf, scanf, sprintf, viprintf,vprintf, vsprintf.

putc, putchar #include <stdio.h>

int putc(int c, FILE *f);int putchar(int c);

Escribe un carácter en un flujo (putc) o en stdout (putchar).

putc(´*´, demo);

Funciones relacionadas: fputc, fputchar, getc, getchar.

putch #include <stdio.h>

int putch(int c);

Escribe un carácter 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 estándar 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[,dirección,...]);

Lee datos con formato del flujo de entrada estándar.

Código Formato

%c Carácter.%d Entero decimal.%x Hexadecimal.%i Entero decimal.%f Número real.%o Octal.%p Puntero.%s Cadena.

��� ������������������������������������ ��������� �($

Page 30: Bibliotecas Borland y c++f

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 tamaño l y el tipo t con el flujo (archivo) f. Losvalores 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 enque la salida generada se sitúa 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[,dirección,...]);

Esta función es idéntica a scanf, excepto que los datos son leídos delarray 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);

Sitúa un carácter, excepto la constante EOF, en el buffer asociado con unarchivo abierto para entrada con buffer.

ungetc(car, stdin);

Funciones relacionadas: getc.

ungetch #include <stdio.h>

int ungetch(int ch);

�(( ������������������ �������� �������������!���

Page 31: Bibliotecas Borland y c++f

Empuja un carácter 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 quevscanf 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_valista_arg);

Funciona igual que sscanf, excepto que en vsscanf es utilizado unpuntero 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.

�������������������

Las declaraciones de las funciones de bajo nivel se incluyen en los archivosde cabecera io.h, fcntl.h, sys|types.h y sys|sta.h. A diferencia delas funciones stream, las funciones de bajo nivel no requieren el archivo deinclusión 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()actúa igual que creat(), excepto que utiliza un byte de atributo del DOS.

��� ������������������������������������ ��������� �(�

Page 32: Bibliotecas Borland y c++f

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 directorioescrito 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 enlacede 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 dearchivo (se devuelve 1 si se alcanza el final del archivo. 0 si no se alcanzael final del archivo, –1 indica un error y errno toma valor EBADF: númerode 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 función lseek mueve el puntero asociado con el descriptor d a unanueva posición 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 operación permitida y m el tipo de permiso.

Indicador SignificadoLectura/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.

�(� ������������������ �������� �������������!���

Page 33: Bibliotecas Borland y c++f

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 dered y con el tipo s de compartición permitido en el archivo y modo m.

Indicador SignificadoLectura/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 porbuffer.

read(fx, buffer, 100);

tell #include <io.h>

long tell(int d);

Devuelve la posición 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 ddesde el buffer apuntado por buffer).

write(fx, grande, 60000);

Funciones relacionadas: creat, open, read, sopen.

�����������������������������

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 lacadena y su longitud en la posición 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 quecprintf no traduce el carácter (\n) a una combinación (CR-LF), en su lugar,

��� ������������������������������������ ��������� �("

Page 34: Bibliotecas Borland y c++f

\n se interpreta como avance de línea (LF) y \r se debe utilizar para indicarun 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 envía ningún carácter de nuevalínea después de la cadena.

cuts(“Está usted seguro(s/n)?”);

Funciones relacionadas cprintf.

cscanf #include <conio.h>

int cscanf(char *formato [,dirección,...]);

Lee caracteres con formato directamente desde la consola en la posicióndada por dirección.

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 carácter 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 puertode E/S especificado por puerto.

La función inport es útil para leer dos puertos adyacentes a la vez, einportb 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 teclawhile(!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);

�(# ������������������ �������� �������������!���

Page 35: Bibliotecas Borland y c++f

Escribe una palabra de 16 bits (outport) un byte (outportb) en unpuerto de E/S.

outport(23,0); // 23 fuera del puertooutport(´A´, 0) // A fuera de puerto

Funciones relacionadas: inp, inport, inportb, inpw.

putch #include <conio.h>

int putch(int c);

Escribe un carácter en la consola (sin acción del buffer).

putch(car); putch(´\n´); putch(´x´);

Funciones relacionadas: getch, getche.

ungetch #include <conio.h>

int ungetch(int c);

Sitúa un carácter en el buffer del teclado de modo que es el siguientecarácter leído en la consola.

if(c =!EOF) ungetch(c);ungetch(car);

Funciones relacionadas: getch, getche, ungetc.

����� �������������������*�,��

El sistema de archivos es un componente clave del/de la PC. Todas las apli-caciones y datos residen en archivos. Las funciones de gestión de archivospermiten establecer y verificar permisos de acceso a archivos. La mayoríade las funciones están en el archivo de cabecera io.h, y las restantes ensys|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 tamaño del archivo.

chsize(fh, 5);

Funciones relacionadas: access, chmod, fstat, stat.

��� ������������������������������������ ��������� �('

Page 36: Bibliotecas Borland y c++f

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 extensión del archivo). En Microsoft, la función equi-valente es _makepath.

fnmerge(camino,”C:”,\\aux,”resultado”,”.dat”);// nombre de camino”C:\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 extensión 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 información sobre el archivo especificado en la estructura detipo stat apuntada por buffer. La estructura stat es:

struct stat {short st_dev; // unidad o dispositivoshort st_ino; // número inodo (UNIX)short st_mode // modo archivoshort st_nlink; // número enlaces (DOS,1)int st_uid; // id de usuario (UNIX)int st_gid; // id de grupo (sólo UNIX)int st_rdev; // dispositivo UNIXlong st_size; // tamaño archivo en byteslong st_atime; // hora último accesolong st_mtime; // hora última (UNIX)long st_ctime; // hora creación

};

fstat(fich, &info);

Funciones relacionadas: access, chmod, stat.

isatty #include <io.h>

int isatty(int h);

Determina si es un dispositivo orientado a carácter (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 número de bytes n del archivo h (manejador) con desplaza-miento se utiliza para compartición de archivos (orden SHARE de MS-DOS). En Visual C++, la función equivalente es locking.

res lock(h, 0L,256); bloque de 256 bytes

Funciones relacionadas: sopen, unlock.

��� ������������������ �������� �������������!���

Page 37: Bibliotecas Borland y c++f

mktemp #include <dir.h>

char * mktemp(char *plantilla);

Crea un único nombre de archivo modificando una plantilla dada comoargumento, 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 información 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 máscara de permisos de lectura/escritura usados por openy create.

Pmodo S_IREAD (sólo lectura)S_IWRITE (sólo escritura)S_IREAD|S_IWRITE (lectura/escritura)

viejamascara = umask(S_IWRITE);

Funciones relacionadas: chmod, creat, mkdir, open, sopen.

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 sólo lectura.

result = unlink (“demo.jnk”);if (result==0)

printf (“unlink tuvo éxito”);

Funciones relacionadas: remove.

��� ������������������������������������ ��������� ���

Page 38: Bibliotecas Borland y c++f

unlock #include <conio.h>

int unlock(int h, long o, long l);

Desbloquea una sección del archivo h que ha sido bloqueada con lock.

unlock(m,OL,256); // desbloquea 256 bytes

Funciones relacionadas: lock, sopen.

����� ������������������

El C original de K&R fue diseñado, inicialmente, como un lenguaje de pro-gramación de sistemas, su uso ha sido muy escaso en el campo del cálculocientífico. Sin embargo, desde la normalización de ANSI C y su extensabiblioteca matemática, C se ha convertido en un fuerte rival del lenguajecientífico por excelencia, FORTRAN. C soporta operaciones de coma flo-tante e incluye también un rico conjunto de funciones matemáticas. BorlandC++ ha ampliado las propiedades de ANSI C estándar.

Los archivos de cabecera que contienen funciones matemáticas son:bcd.h, complex.h, float.h, math.h, stdlib.h. Las funciones de 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.

Además de estas funciones, Borland C++ soporta dos clases específicasimportantes: complex y bcd, se encuentran en los archivos complex.h ybcd.h, respectivamente.

�����3425607

Borland C++ incluye una estructura complex en el archivo de cabeceramath.h, cuyos miembros son la parte real e imaginaria de un número com-plejo z y que se define así:

struct complex{

double x; // parte real del número complejodouble y; // parte imaginaria del complejo

}

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

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.

����� 839

La clase bcd permite manipular números almacenados en notación decimalcodificado a binario (BCD) y proporciona hasta 17 dígitos decimales deprecisión, y un rango de 1 × 10-125 a 1 × 10125.

abs versión real #include <math.h>#include <stdlib.h>

versión compleja #include <complex.h>

int abs (int x);double abs(complex x);

Proporciona el valor absoluto de un entero o de un número complejo:abs(-50) devuelve 50. Para utilizar números complejos se requiere elarchivo 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 función acos() devuelve el arco coseno de x, cuyo valor debe estaren 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);

��� ������������������ �������� �������������!���

Page 39: Bibliotecas Borland y c++f

La función arg() devuelve el ángulo, en radianes, de un número en elplano complejo.

complex z;double angulo;z = complex(1.5, 4.5);angulo = arg(z);

Funciones relacionadas: complex, norm, polar.

asin versión real #include <math.h>versión compleja #include <complex.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 función asin() devuelve un valor entre – /2 y ,el valor de x debe ser en radianes.

Z = asin(0.7543);

Funciones relacionadas: matherr, sin.

atan versión real #include <math.h>versión compleja #include <complex.h>

double atan(double x);

Calcula el arco tangente de x. El rango x es –1 a 1. La función atan()devuelve un valor en el rango de – /2 a /2.

#include <complex.h>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 valorcomprendido 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 número complejo almacenado en unaestructura de tipo complex.

struct complex z;double complejo;z.y = 3.5z.y = 2.4complejo = 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 número 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.

��� ������������������������������������ ��������� ��$

Page 40: Bibliotecas Borland y c++f

_control87 #include <float.h>

unsigned int _control87(unsigned int nuevo, unsigned intmascara);

Obtiene y establece la palabra de control de coma flotante. Cuando seutiliza un coprocesador matemático 8087, _control87 establece su palabrade control.

estado = control87(PC24,MCW_IC);// precisión 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 enradianes 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 hiperbólico de la variable x. Si el argumento pasadoa cosh() es demasiado grande, se produce un error de rango.

x = 1.00printf(“x = %f.\n\n”,x);y = cosh(x);printf(“coseno hiperbólico x = %f.\n\n”, y);

Funciones relacionadas: sinh.

div #include <stdlib.h>

div_t div(int x, int y);

La función div() calcula el cociente entero y el resto de x por y. Lafunción devuelve una estructura div_t definida en stdlib.h como

typedef struct{

int quot; // cocienteint rem; // resto

} div_t;

div_t resultado;resultado = div(35, 8);// resultado.cociente = 4, resultado.resto = 3

exp #include <amth.h>#include <complex.h>

double exp(double x);complex exp(complex x);

Calcula el exponencial de x:ex; 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 número en coma flotante x.

y = fabs(-7.25); // y vale 7.25

Funciones relacionadas: cabs.

floor #include <math.h>

double floor(double x);

��( ������������������ �������� �������������!���

Page 41: Bibliotecas Borland y c++f

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 división 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 matemático de coma flotante. Debe utilizarsedespués de las llamadas a las funciones system(), exec(), span() sobremáquinas con coprocesadores matemáticos.

_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 función frexp descompone el valor x en una mantisa (m) y en unexponente n, tal que el valor absoluto de m es mayor o igual a 0,5 y menorque 1,0 y x + m*2n. La mantisa se obtiene por la función, y el exponente sealmacena en la variable apuntada por exp.frexpl descompone un valorlong 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 triángulo rectángulo cuyos lados son x e y.Una llamada a hypot equivale a lo siguiente:

sqrt(x * x, y * y);

double x = 3.0; y = 4.0;printf(“%lf”, hypot(x, y));

imag #include <complex.h>

double imag(complex x);

Devuelve la parte imaginaria de un número complejo x. Esta función noes 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.

��� ������������������������������������ ��������� ���

Page 42: Bibliotecas Borland y c++f

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*eexp.

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 división x/y. La función ldivdevuelve una estructura de tipo ldiv_t que comprende el cociente y elresto.

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>#include <complex.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 valorHUGE_VAL. Si x es 0, la función imprime un mensaje de error SING enstderr, 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 rotación de un bit a la izquierda, una posición, sig-nifica que el bit más a la izquierda sale fuera y se inserta en su posición elsiguiente bit de mayor peso, y los restantes bits se desplazan una posición ala 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. Rotación a derecha de un bit significasalir fuera el bit de menor peso y los restantes se desplazan una posición ala 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)

��� ������������������ �������� �������������!���

Page 43: Bibliotecas Borland y c++f

Esta función manipula errores matemáticos. Las funciones matemáticasllaman a la rutina adecuada matherr cuando se detecta un error. Se puededesarrollar su propia versión de matherr para personalizar su tratamientode errores. Para profundizar en esta función, consultar su referencia enLibrary Reference de Borland C++ (págs. 352-353).

Funciones relacionadas: Las funciones matemáticas.

max #include <conio.h>

(tipo) max(a, b);

Devuelve el mayor de dos valores. Ambos argumentos y la declaraciónde la función 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 declaraciónde la función 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 función modf divide un número de coma flotante en dos partes, ente-ra y decimal. La parte entera de x se almacena en la posición a cuya direc-ción apunta partent, y la parte decimal es devuelta por la función.

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 número complejo con una magnitud (módulo) y ángulodado.

complex < = complex(x, y);

polar(mag, ang)es lo mismo que complex(mag*cos(ang), mag*sin(ang);

Funciones relacionadas: Sólo existe en C+.

poly #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 expresión utilizada paraevaluar el polinomio es:

c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]

// polinomio: 3x**2 + 2x + 1//double c[] = {-10.0,2,c);

Funciones relacionadas: pow.

rand #include <stdlib.h>

int rand(void);

Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; estaconstante simbólica está definida en <stdlib.h> y su valor es 215-1. Para ini-cializar el generador de números pseudoaleatorios se debe utilizar randomize.Para obtener un número en el rango de 0 a (n-1) hay que utilizar random.

// visualizar 10 números aleatorios //for(i = 0; 1 < 10; i++)

printf(“%6d\”, rand());

Funciones relacionadas: random, randomize, srand.

��� ������������������������������������ ��������� ��"

Page 44: Bibliotecas Borland y c++f

random #include <stdlib.h>

int random(int x);

Genera un número pseudoaleatorio en el rango de 0 a x-1.

// obtener un número aleatorio entre 0 y 20numa1 = random(21);

Funciones relacionadas: rand, randomize.

randomize #include <stdlib.h>#include <time.h>

void randomize(void);

Inicializa (genera una semilla) el generador de números pseudoaleato-rios con una semilla aleatoria que es función de la hora actual. Esta funciónimpide que se repitan las mismas secuencias de números 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 número complejo x o convierte un númeroBCD a float, double o long double.

complex z = complex(x, y)cout << “parte real:” << real(z) << “\n”;

Funciones relacionadas: Función 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>#include <complex.h>

double sin(double x);complex sin(complex x);

La función 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>#include <complex.h>

double sinh(double x);complex sinh(complex x);

Devuelve el seno hiperbólico de x (x, se supone en radianes).

y = sinh(x);

Funciones relacionadas: sin, cosh.

��# ������������������ �������� �������������!���

Page 45: Bibliotecas Borland y c++f

sqrt #include <math.h>

double sqrt(double x);complex sqrt(complex x);

Calcula la raíz cuadrada de un número x no negativo.

printf(“%lf”,sqrt(25.0); // se visualiza 5

Funciones relacionadas: exp, log, pow.

srand #include <stdlib.h>

void srand(unsigned x);

srand inicializa el generador de números aleatorios con la semilla x. Six 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>#include <complex.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>#include <complex.h>

double tanh(double x);complex tanh(complex x);

Calcula la tangente hiperbólica de x.

a = tanh(x);

Funciones relacionadas: cosh, tanh.

���$� ��������������� ������� �&��

�������)������+

Las rutinas de manipulación de buffers son una forma general de las rutinasde manipulación de cadenas que operan sobre éstas en C. Son útiles para tra-bajar con áreas de memoria sobre la base de carácter a carácter. Un buffer esun array de caracteres similar a una cadena de caracteres. Sin embargo, alcontrario que las cadenas, los buffers no terminan normalmente con uncarácter nulo (´\0´). Por consiguiente, las rutinas de manipulación de buf-fers siempre toman un argumento longitud o cuenta.

Las rutinas de manipulación requieren que el archivo de cabecera<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 cse 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);

��� ������������������������������������ ��������� ��'

Page 46: Bibliotecas Borland y c++f

Busca un carácter específico 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 número de bytes de un buffer (b1) con otro (b2) sin hacercaso del tamaño de las letras en los dos buffers.

if(memicmp(buf1, buf2, 15) == 0)puts(“Los buffers son iguales en los 15 primeros bytes \n”);

Funciones relacionadas: memcmp.

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 carácter 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 eldesplazamiento fuente, ds es el segmento destino, do es el desplazamientodestino y n es el número 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.

��� ������������������ �������� �������������!���

Page 47: Bibliotecas Borland y c++f

setmem #include <mem.h>

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

Fija un bloque de long bytes en el buffer dest al carácter c. setmem esútil para inicializar buffers.

setmem(buffer, 60, ´t´);

Funciones relacionadas: memset.

swab #include <stdlib.h>

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

Copia un número par de bytes de una posición a otra, intercambiando almismo tiempo cada par de bytes adyacentes.

swab(“mnpq”, resultado, 4);// resultado es “nmpq”

Funciones relacionadas: Sólo está disponible en sistemas UNIX.

���(� ���������������������:��

Las funciones de presentación de texto permiten definir coordenadas de unaventana de texto en la pantalla y manipular texto. Con estas funciones sepuede posicionar texto en cualquier parte de la pantalla, seleccionar atribu-tos de texto (tales como subrayado, vídeo inverso, parpadeo, colores defondo 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 línea actual desde la posición del cursor al final de la línea.

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 línea completa que contiene el cursor y desplaza hacia arribalas líneas 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 cuyadirección 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 información relativa a las coordenadas de la ventana actual,posición del cursor dentro de la ventana, atributo del texto, las dimensiones

��� ������������������������������������ ��������� ���

Page 48: Bibliotecas Borland y c++f

de la pantalla y el modo de texto actual. La información se devuelve en unaestructura text_info.

struct text_info {unsigned char winleft; // coordenadas x, y esquina superior

// izquierdaunsigned char wintop; // ventana actualunsigned char winright; // coordenadas x, y esquina inferior

// derechaunsigned char winbottom; // ventana actualunsigned char attribute; // atributo texto actualunsigned char normattr; // atributo texto normalunsigned char currmode; // modo texto actualunsigned char screenheight;// altura de la pantallaunsigned char screenwidth; // anchura pantallaunsigned char curx; // coordenada x cursorunsigned char cury; // coordenada y cursor};

gotoxy #include <conio.h>

void gotoxy(int x, int y);

Mueve el cursor a una posición especificada (columna x, fila y) dentrode 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 línea en blanco en la ventana de texto actual en la posicióndel cursor, desplazando el resto de las líneas 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 modotexto) a otro rectángulo 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 tenían antes de que arran-que el programa.

normvideo();

Funciones relacionadas: highvideo, lowvideo, textattr, textco-lor.

��� ������������������ �������� �������������!���

Page 49: Bibliotecas Borland y c++f

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 pantallaen 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 seruna de las constantes.

_NOCURSOR Desactiva el cursor._SOLIDCURSOR Un carácter bloque sólido 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 aparienciadel 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 ycputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15WHITE (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.

��� ������������������������������������ ��������� ��$

Page 50: Bibliotecas Borland y c++f

wherex #include <conio.h>wherey

int wherex(void);int wherey(void);

Determina la coordenada x (wherex) y la coordenada y (wherey) de laposición 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 región rectangular de la pantalla como la ventana de textoactual 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.

��( ������������������ �������� �������������!���