APÉNDICE F
CONTENIDO
Esta parte es una revisión breve de la biblioteca de rutinas (funciones) y F.2. FUNCIONES DE ASIGNACIÓN DE MEMORIA
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 Borland C++ almacena información en la memoria principal de la compu-
diseñadas para su uso en programas C++. La biblioteca en tiempo de ejecu- tadora por dos métodos. El primero utiliza variables globales y locales
ción hace la programación más fácil, ya que incluye una amplia variedad de (incluyendo arrays, cadenas y estructura); en este caso, el almacenamiento
tareas tales como E/S de bajo y alto nivel, manipulación de cadenas y archi- o longitudes fija. Para cambiar el tamaño de arrays y cadenas de caracteres
vos, asignación de memoria, control de procesos, cálculos matemáticos, etc. se debe editar el archivo fuente y recompilar su programa. Esta información
Las rutinas de Borland C++ están contenidas en los archivos de bibliote- se almacena en la pila (stack). El segundo método de almacenar informa-
ca Cx.LIB, CPx.LIB, MATHx.LIB y GRAPHICS.LIB. Borland C++ imple- ción es asignar memoria a medida que el programa lo requiera y liberar esta
menta la versión estándar última de ANSI C, que entre otras cosas recomien- memoria cuando ya no se necesita; esta acción permite utilizar la misma
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++.
nombre función archivo de cabecera
memoria para colas diferentes en un tiempo distinto. Este proceso de asig- datos de un programa. Si hay éxito se devuelve 0; en caso contrario, –1, y la
nar memoria se denomina asignación dinámica de memoria. variable global errnoc toma el valor ENOMEN (insuficiente memoria).
Por omisión, cada vez que se ejecuta un programa, DOS establece un
segmento de 64 Kb denominado segmento de código, que contiene su códi- it(brk(nuevo_break) == -1)
go programa. DOS establece también un segmento de 64 Kb denominado perror(“brk ha fallado”);
segmento de datos. Su programa puede tener múltiples segmentos de datos
y códigos. Funciones relacionadas: free, farmalloc, malloc, sbrk.
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. calloc #include <stdlib.h>
#include <alloc.h>
Segmento de datos
int *calloc(size_t n, size_t s);
Montículo Pila Datos del programa
(heap) (stack) Asigna memoria principal (un bloque de tamaño n.s). El bloque se
borra (limpia) a 0. Si se desea asignar un bloque mayor que 64 Kb, se debe
utilizar farcalloc. Devuelve un puntero al bloque recién asignado. Si no
Después de asignar partes del segmento de datos a variables estáticas y
existe bastante espacio para el nuevo bloque o bien n o s es 0, calloc
globales y a la pila, el compilador dedica el resto del segmento de datos al
devuelve nulo.
montículo o heap.
Borland C++ contiene un gran número de funciones para asignación long *buffer
dinámica de memoria, que realizan una gran variedad de tareas: asignar y buffer=(long *) calloc(40, sizeof(long));
liberar memoria del montículo y de la pila, obtener información de bloques
de memoria, etc. Funciones relacionadas free, malloc.
unsigned long farcoreleft(void); Verifica la consistencia de un solo bloque en el montículo (heap) far.
Determina el número total de bytes disponibles en el sistema. estadoheap = farheapchecknode(arraygrande);
memoria_total_disponible = farcoreleft();
farheapfillfree #include <alloc.h>
Funciones relacionadas: coreleft, farcalloc, farmalloc.
int farheapfillfree(unsigned int f);
farfree #include <alloc.h> Rellena todos los bloques libres del montículo far con un valor constante.
void far *farrealloc(void far *b, unsigned long n) int heapcheckfree(unsigned int f);
Se utiliza para reasignar (ajustar el tamaño de un bloque de memoria b, Verifica la consistencia de los bloques libres en el montículo (heap).
al cual se ha asignado una longitud de n bytes).
estadoheap = heapcheckfree(´N´);
if(bloquegrande = farrealloc(bloquegrande, 120000L)) = NULL
printf(“Fallo reasignación memoria\n”); Funciones relacionadas: farheapcheckfree, heapfillfree, heapwalk.
char *cad;
// asignar memoria para cadena heapfillfree #include <alloc.h>
cad = (char *) malloc(50);
int heapfillfree(unsigned int f);
...
free(cad); // liberar memoria Rellena cada byte de todos los bloques de memoria no utilizados en el
montículo con un valor de carácter especificado. En Visual C++ la función
Funciones relacionadas: calloc, malloc, realloc equivalente es –heapset.
estadopila = heapfillfree(´Z´);
heapcheck #include <alloc.h>
Funciones relacionadas: farheapfillfree, heapcheck, heapcheck-
int heapcheck(void); free, heapwalk.
Funciones relacionadas: heapcheckfree, heapchecknode, heapfill- Se utiliza para obtener información sobre las entradas en el montículo
free, heapwalk, farheapcheck. (heap). La función equivalente en Visual C++ es _heapwalk.
apenf.qxd 26/11/99 14:17 Página 619
struct heapinfo i;
setblock #include <alloc.h>
estadoheap = heapwalk(&i);
int setblock(unsigned seg, unsigned n);
Funciones relacionadas: farheapwalk, heapcheck.
Ajusta el tamaño de un bloque de memoria asignado anteriormente por
allocmen. Esta función llama a la función 4Ah de DOS para ampliar el
malloc #include <stdlib.h>
tamaño de un bloque de memoria previamente asignado por allocmen. En
#include <alloc.h>
las versiones Visual C++ la función equivalente es _dos_setblock.
void *malloc (size_t n);
F.3. FUNCIONES DE BÚSQUEDA Y ORDENACIÓN
Asigna memoria a bloques en el montículo. Devuelve un puntero, que
es la dirección inicial de la memoria asignada. La mayoría de los programas requieren casi siempre alguna operación de
clasificación y búsqueda de elementos en arrays. Borland C++ incluye dife-
cadena = malloc(MAX_CHR)
rentes funciones que realizan estas tareas.
Funciones relacionadas: calloc, free, realloc.
bsearch() #include <stdlib.h>
main(void)
lsearch #include <stdlib.h> {
int i;
void * lsearch(const void *k, const void *a, size_t *n, size_t W,
int(*comparar) (const void*, const void *)); printf(“lista original:”);
for(i =0; i < 10; i++)
La función lsearch realiza una búsqueda lineal de la clave k. El printf(“%d”, numeros[i]);
array a contiene n elementos de anchura W. La función comparar se uti- qsort(numeros,10,sizeof(int), comparar);
liza para comparar la clave con el elemento actual del array. Al contrario printf(“lista ordenada:”);
for(i = 0; i < 10; i++)
que bsearch(), en la función lsearch() el array no tiene que estar printf(“%10, numeros[i]);
ordenado. lsearch() devuelve un puntero al primer elemento del array return 0;
que se corresponde con la clave. Si no existe la clave en el array, se }
devuelve 0 y un registro se añade al array con un valor de k.
La diferencia entre lsearch() y lfind() es que lsearch() añadirá // comparar enteros
un registro al final del array con un valor de la clave si ese registro no se ha comparar(const void *i, const void *j)
encontrado en el array. {
return ((int *)i) – ((int *) j)
Funciones relacionadas: bsearch, lfind, qsort. }
void qsort(void a, size_t n, size_t w, int(*comparar) (const void*, F.4. FUNCIONES DE CADENA
const void*));
C no tiene el tipo de datos cadena (string). En su lugar, las cadenas se tratan
La función qsort ordena un array con un número dado de elementos como arrays de caracteres, cada uno de los cuales ocupa un byte. Por notación
utilizando el método de ordenación rápida quicksort (creado por C.A.R. el final de una cadena en C se representa por un byte que contiene un carácter
Hoare). El número de elementos de array es n y el tamaño (en bytes) de cada nulo (´\0´). Las cadenas pueden ser declaradas como arrays de caracteres.
elemento es w. La función comparar se utiliza para comparar un elemento
del array con la clave; devuelve los siguientes valores: char cad[20], cad 5[] = “Hola Mortimer”;
apenf.qxd 26/11/99 14:17 Página 621
A las cadenas se accede directamente a través de su índice, como en el char *strchr(const char *cad, int c);
ejemplo anterior, o bien a través de un puntero.
strchr() encuentra la primera aparición de c en cad y devuelve un
char cad5[] = “Hola Mortimer”; puntero a la primera aparición de c en cad. Si c no se encuentra, devuelve
char *p_cad5; un cero (NULL).
p_cad5 = cad5;
printf(“%s”, strchr(“Salario mensual = $85725”, ´$´));
Se puede también declarar e inicializar una cadena a la vez:
visualizará $85725
char *p_cad5 = “Hola Mortimer”;
char *s[81] = “Esta es una cadena de prueba”;
char *ptr;
El archivo de cabecera <string.h> contiene numerosas funciones que ptr = strchr(s, ´a´);
manipulan cadenas.
el valor almacenado en ptr es un puntero a la primera aparición de ´a´.
< 0 si cad1 < cad2 ce del primer carácter de cad1, que pertenece al conjunto de caracteres de
= 0 si cad1 = cad2 cad2.
> 0 si cad1 > cad2
primero = strcspn(“circunloquio”, “q”);
v = strcmpi(c1, c2);
// primero = 8
Funciones relacionadas: strcmp, stricmp, strncmp, strnicmp.
Funciones relacionadas: strpbrk, strspn.
it stricmp(const char *cad1, const char *cad2); char *strncat(char *cad1, const char *cad2, size_t n);
Esta función se utiliza para comparar una cadena a otra sin tener en La función strncat() añade los primeros n caracteres de cad2 a cad1,
cuenta el tamaño de las letras. Convierte todos los caracteres alfabéticos de y termina la cadena resultante un carácter nulo. Si cad2 es mayor que n
cad1 y cad2 en minúsculas; a continuación, se comparan las dos cadenas y caracteres de longitud, strncat() truncará la cadena a la longitud de n. En
devuelve un valor entero que indica el orden lexicográfico de cad1 con res- otro caso, concatenará la cadena completa.
pecto a cad2.
char *a = “Sierra Madre”;
Si cad1 = cad2 el valor de la función es cero. char *b = “de la ciudad de Monterrey”;
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. cout << strncat(a, b, 4) << ´\n´;
cout << strncat(a, b) << ´\n´;
Resultado = stricmp(cad1, cad2),
Funciones relacionadas: strcat, strdup, strcpy, strncpy.
Funciones relacionadas: strcmp, strcmpi, strncmp, strnicmp.
cout << “Ambas cadenas comienzan con \Mortimer\”; Encuentra la última aparición del carácter c en cad. Devuelve un pun-
else teo a la última aparición de c o un carácter nulo si c no está en cad.
cout << “Estas cadenas no comienzan con \Mortimer\”;
char *nombrearch = “c: /usr/tst/libro/cap1.txt”;
Funciones relacionadas: strcmp, strcoll, stricmp, strncmp, str- cout << (strrchr(nombrearch, ´/´)+1 << ´\n´;
nicmp.
Funciones relacionadas: strchr.
strnset #include <string.h>
Inicializa los caracteres de una cadena a un valor dado (blanco u otro char *strrev(char *cad);
carácter). Devuelve un puntero a la cadena cad. El carácter c se utiliza para
rellenar la cadena con ese carácter; n es el número de posiciones de carac- Invierte los caracteres de la cadena cad. El carácter de terminación nulo
teres que se han de inicializar. permanece en el mismo lugar. strrev() devuelve un puntero a la cadena
inversa.
printf(“Introduzca una cadena:”); Aplicación: Invertir una cadena leída del teclado e imprimir el resultado.
gets(cadena);
printf(“Introducir un carácter:”); #include <stdio.h>
c = getche(); #include <string.h>
long = strlen(cadena)/2; main()
strnset(cadena, c, lon); {
char demo[80]
printf(“Introduzca una cadena:”);
Funciones relacionadas: memset, setmem, strset. gets(demo);
strrev(demo);
printf(“La cadena inversa es:\n %s |\n”, demo);
strpbrk #include <string.h> return 0;
}
char *strpbrk(const char *cad1, const char *cad2);
Funciones relacionadas: strcpy, strncpy.
Encuentra la primera aparición en cad1 de cualquiera de los caracteres
de cad2. El carácter nulo no se incluye en la búsqueda. Si el carácter no
existe, se devuelve un carácter nulo (NULL).
strset #include <string.h>
char *s = “Mortimer L.J. Mackoy”;
char *p = strpbrk(s, “L4”); char *strset(char *cad, int c);
cout << p << ´\n´; // la salida es L.J.Mackoy
Establece todos los caracteres de la cadena cad al valor de c. Termina
Funciones relacionadas: strchr, strcspn. cuando se encuentra el primer carácter nulo. Devuelve un puntero a la cade-
na modificada.
strstr #include <string.h> size_t strxfrm(char *cad1, char *cad2, size_t n);
char *strstr(const char *cad1, const char *cad2); Convierte cad2 en cad1 basado en información específica local y con
un número máximo de caracteres a situar en cad1 de n. En el siguiente
Localiza la primera aparición de una cadena en otra. Si tiene éxito, la ejemplo, strxfrm transforma los tres primeros caracteres de cad1 en los
función strstr devuelve un puntero a la primera aparición de cad2 como tres primeros caracteres de cad2.
una subcadena de cad1. Si la búsqueda falla, se devuelve NULL.
char *cad1 = “abcdefg”;
char *s = “Mi autor favorito es Octavio Paz” char *cad2 = “1234567”;
char *a = “Octavio Paz”;
cout << “La subcadena” << a << “se encuentra:” clrscr();
<< strstr(s, a) << ´\n´; strxfrm(cad1, cad2, 3);
printf(“Transformada: %s\n”, cad1);
Funciones relacionadas: strchr, strcspn, strpbrk
Asimismo, existen otras funciones en el archivo ctype.h que sirven iscntrl, isdigit #include <ctype.h>
para convertir caracteres en mayúsculas en minúsculas, y viceversa; y valo- isgraph, islower
res enteros en códigos ASCII. isprint, ispunct, isspace
isupper,isxdigit
Comprueba si un carácter c es un carácter ASCII; c está en el rango 0-127. Cada macro (función) devuelve un valor distinto de cero si c satisface
Los caracteres 128 a 255 de ASCII son tratados por iascii() como no ASCII. el criterio de esa macro; en caso contrario, devuelve un cero.
carac = getch();
if(isascii(carac)) if(isprint(c)) printf(“\n %c imprimible\n”, c);
printf(“%c es ASCII \n”, carac); if(iscntrl(c)) printf(“%c es un carácter de control\”, c);
else if(isdigit(c)) printf(“%c es un dígito\n”, c);
printf(“%c no es ASCII \n”, carac); if(islower(c)) printf(“%c es letra minúscula\n”, c)
Convierte la fecha y hora almacenada como valor de tipo time_t en una Obtiene la hora actual y la almacena en la estructura timeb apuntada
cadena de caracteres (mes día hora año\0). por ptrhora.
struct timeb {
time_t hora;
long time; // segundos desde 00:00:00 hora GMT
hora = time(NULL);
short millitm; // milisegundos
printf(“Hora actual=%s\n”, ctime(&hora)); short timezone; // diferencia en minutos
// hora Greenwich y hora local
Funciones relacionadas: asctime, ftime, strtime, time. short dstflag; // hora de verano, ahorro de luz
};
long dostounix(struct date *f, struct time *h); Funciones relacionadas: dostounix, gettime, setdate, settime.
Convierte la fecha y hora DOS (devuelta por getdate y gettime) en
formato UNIX. gettime #include <dos.h>
time_t t;
struct time dos_hora; void gettime(struct time *t);
struct date dos_fecha;
gatdate(&Dos_hora); Obtiene la hora actual del sistema. Los componentes de la hora se alma-
gettime(&dos_fecha); cenan en la estructura time definida en dos.h.
t = dostounix(&dos_fecha, &dos_hora);
struct time {
Funciones relacionadas: ctime, gatdate, gettime. unsigned char ti_min // minutos (0-59)
apenf.qxd 26/11/99 14:17 Página 629
struct time hora; Cambia la fecha actual del sistema. Los componentes de la fecha (día,
gettime(&hora); mes. Año) se especifican en los campos de la estructura date.
Funciones relacionadas: dostounix, getdate, setdate, settime. struct date {
int da_year; // año actual
char da_day; // día mes
char da_mon; // mes, 1 para enero, 2...
gmtime #include <time.h> };
struct tm *gmtime (const time_t *hora); En Visual C++ la función equivalente es _dos_setdate.
ahora = gmtime(&hoy);
settime #include <dos.h>
Funciones relacionadas: asctime, ctime, ftime, localtime, time.
void settime(struct time *h);
tiempoactual = localtime(&ahora);
stime #include <time.h>
Funciones relacionadas: asctime, gmtime, time.
int stime(time_t *t);
strftime #include <time.h> Convierte a formato DOS un valor de hora en el formato UNIX.
fnmerge #include <dir.h> getcwd obtiene el nombre de camino completo del directorio de traba-
jo actual, incluyendo el nombre de la unidad. El argumento numcar indica
void fnmerge(char *camino, const char *u, const char *dir, a getcwd el máximo número de caracteres que el buffer camino puede con-
const *nombrearch, const char *ext); tener. La función getcwd es útil para obtener el nombre del directorio actual
y guardarlo. Si su programa cambia los directorios de trabajo durante su eje-
Crea un nombre de camino completo compuesto de una letra de la uni- cución, puede utilizar el nombre guardado para restaurar el directorio de tra-
dad (u), camino del directorio (dir), nombre de archivo (nombrearch) y bajo actual antes de terminar.
extensión del archivo (ext).
fnmerge(camino, “c:”, \\aux\\”,”demo”,”.dat”); getcwd(cuentas, 80)
int getdisk(void);
mktemp #include <dir.h>
La función getdisk obtiene el valor entero que representa la unidad
actual (0, unidad A; 1, unidad B...) char *mktemp(char *plantilla);
int unidad; Crea un nombre de archivo a partir de una plantilla. Devuelve un pun-
clscr(); tero al nombre del archivo si tiene éxito y nulo en caso de error.
unidad = getdisk();
mktemp(nombre);
Funciones relacionadas: setdisk.
Elimina el directorio escrito por la variable camino, siempre que el Busca un archivo específico en una lista de directorios, incluyendo el
directorio esté vacío, no sea el directorio raíz y no sea el directorio de tra- directorio de trabajo actual y los definidos en la variable de entorno PATH.
bajo rmdir(); devuelve 0 si la operación de borrado tiene éxito; si se pro- Si el archivo se encuentra, se devuelve un puntero al nombre del camino del
duce un error, el valor devuelto es –1 y la variable global errno se fija a uno archivo; en caso contrario, se devuelve NULL.
de los siguientes valores:
buffer = searchpath(“BC.EXE”);
EACCES Permiso denegado.
ENOENT Camino archivo no encontrado. Localizar el archivo AUTOEXEC.BAT en los directorios definidos en la
variable de entorno PATH.
Esta función es similar a RMDIR o RD de MS-DOS.
buffer = searchpath(“autoexec.bat”);
rmdir(“C:\\PRUEBAS”); Supresión de directorio PRUEBAS
Crea un directorio con un nombre de camino especificado. Funciona Cambia a una nueva unidad por omisión. El valor de la unidad (unidad)
igual que la orden MKDIR o MD de DOS. Devuelve 0 si el directorio se ha es un entero.
creado con éxito o –1 si se produce un error; en este caso, la variable global Unidad A
errno toma el valor EACCES (permiso denegado) o ENOENT (nombre de
B:
camino no válido). C:
EACCES Permiso denegado. D:
...
ENOENT Camino no encontrado.
nuevaunidad = setdisk(3); / nueva unidad actual es C:
resultado = mkdir(“PRUEBAS”);
// crea el directorio PRUEBAS Funciones relacionadas: getdisk
apenf.qxd 26/11/99 14:17 Página 633
abort #include <process.h> int execlpe(char *camino, char *arg0,...argn, NULL, char **env);
#include <stdlib.h> int execv(char *camino, char argv[]);
Funciones relacionadas: abort, atexit, ´exit, exit, ´fpreset, Obtiene información detallada sobre formatos monetarios y numéricos
spawn, system. de diferentes países.
p_lconv = localeconv();
_exit #include <stdlib.h>
Funciones relacionadas: setlocale.
void _exit(int estado);
Termina inmediatamente el proceso actual sin hacer otras operaciones longjmp #include <setjmp.h>
auxiliares (como cierre de archivos).
void longjmp(jmp_buf env, int valor);
_exit(0)
Restaura el estado de la pila y la ejecución local anteriormente grabada
Funciones relacionadas: exit. en env por setjmp.
longjmp(plaza, 3);
getenv #include <stdlib.h>
Funciones relacionadas: setjmp.
char *getenv(const char *nomvar);
perror #include <stdio.h>
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 variables
void perror(const char *cadena);
de entorno y, a continuación, busca una entrada en la lista correspondiente
a nomvar. 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,
varlib = getenv(“LIB”); el mensaje de error correspondiente al valor actual de la variable global
errno y, finalmente, un carácter de nueva línea. Si cadena es un puntero
Funciones relacionadas: putenv. nulo o un puntero a una cadena nula, perror imprime sólo el mensaje de
error del sistema.
getpid #include <process.h> perror(“Error de cierre de archivos”);
Funciones relacionadas: getpsp. Crea nuevas variables de entorno o modifica los valores de las variables
de entorno existentes.
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 a F.9. FUNCIONES DE CONVERSIÓN DE DATOS
longjmp, realizando el efecto de un goto no local.
Las funciones de conversión de tipos de datos sirven para crear un puente de
if(setjmp(env) != 0) printf(“valor de longjmp\n”); unión entre los dos estilos de representación de números: la cadena de texto
legible por los humanos y el formato binario legible por las máquinas. Las
Funciones relacionadas: longjmp. funciones de conversión son ideales para convertir argumentos de líneas de
órdenes de su representación de cadena al formato interno.
Establece tratamiento de señales de interrupción. La función signal per- double atof(const char *cadena);
mite a un proceso elegir uno de los diferentes modos de manipular una señal
de interrupción del sistema operativo. La función atof() convierte el argumento cadena en un valor de doble
precisión. La cadena debe tener el siguiente formato:
signal(SIGINT, SIG_IGN);
[blanco][signo][ddd][.]]ddd][exponente][signo][ddd]
Funciones relacionadas: abort, _control87, exit, longjmp, raise,
setjmp. opcional e/E
Funciones relacionadas: atof, atol, itoa, ltoa, scanf, ultoa. char *fcvt(double valor, int n, int *dec, int *signo);
char *gcvt(double valor, int ndig, char, *buf); double strtod(const char *cad, char **p);
La función gcvt() convierte el argumento valor de doble precisión en La función strtod() convierte la cadena cad en un valor de doble
una cadena de caracteres que se almacena en el buffer cuya dirección se da precisión. La cadena debe tener el formato
en el argumento buf. Se debe asignar bastante espacio en el buffer para con-
[blanco][signo][ddd][.][exponente][signo][ddd]
tener todos los dígitos de la cadena convertida y el carácter nulo de termi-
nación (‘\0’).
+, - d, D, e, E
gcvt(valor, digitos, cadena);
blanco/ dígitos decimales
Funciones relacionadas: atof, ecvt, fcvt, itoa, ltoa, printf, tabulación
sprintf, ultoa.
strtod() devuelve el valor de doble precisión y cero si no se produce la
conversión. La conversión se termina con el primer carácter no reconocible.
Aplicación: Convertir la cadena “843899.567” a un valor de coma flo-
itoa #include stdlib.h> tante double.
#include <stdio.h>
char *itoa(int valor, char *cad, int base);
#include <stdlib.h>
La función itoa() convierte el argumento entero valor en una cadena main()
de caracteres utilizando el argumento base, como base de un sistema de {
numeración (2 a 36). Debe existir bastante espacio en cad para contener 17 double x;
char *num_flt = “843899.567”:
caracteres, itoa() devuelve un puntero a la cadena cad.
char *p;
itoa(32, buffer, 16); // buffer contendrá “20”, ya que 32 entero x = strtod(num_flt, &p);
// equivale a 20 en hexadecimal printf(“x = %f\n”,x);
}
Funciones relacionadas: atoi, atol, itoa, ultoa.
Funciones relacionadas: atof, printf, scanf, strtol, strtoul.
[espacio en blanco][0][x|X][ddd] 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-
dígitos decimales pendientes a estructuras de datos complejos. La E/S por secuencia, o flujo,
octal también proporciona acciones de taponamiento (buffering) que mejoran sig-
blanco o tabulaciones hexadecimal nificativamente el rendimiento. Para utilizar los flujos, generalmente se
debe incluir el archivo stdio.h.
Si la base b es cero, strtoul utiliza el primer carácter de la cadena para
determinar la base del valor. clearerr #include <stdio.h>
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, void clearerr(FILE *f);
la variable errno se pone al valor de ERANTE.
Reinicializa el indicador de error de un flujo f.
i = strtoul(cad_ent, &ptrfin, base);
clearerr(fichen);
Funciones relacionadas: atol, ultoa, strtol. Funciones relacionadas: eof, feof, ferror, perror.
apenf.qxd 26/11/99 14:17 Página 639
Abre un flujo utilizando un handle (entero devuelto por las rutinas de Lee un carácter de la posición actual del archivo y, a continuación,
E/S de bajo nivel, tales como open, creat, dup y dup2); asocia una incrementa esta posición.
estructura de datos FILE con el archivo especificado por handle.
c = fgetc(fp)
p_datos = fdopen(handle, “rb”);
Funciones relacionadas: fgetchar, fputc, fputchar, getc, putc,
Funciones relacionadas: fclose, fopen, fropen, open. putchar.
Comprueba el final de archivo de un flujo. Lee un carácter del archivo stdin, normalmente el teclado.
feof(fichen);
c = fgetchar();
Funciones relacionadas: clearerr, fclose, rewind.
Funciones relacionadas: fgetc, fputc, fputchar, putc, putchar.
Vacía (limpia) todos los buffers asociados con los archivos abiertos.
fileno #include <stdio.h>
numvaciados = flushall();
int fileno(FILE *f);
Funciones relacionadas: fclose, fflush.
Obtiene el mando o manejador (handle) del archivo asociado con un
flujo.
fprintf #include <stdio.h>
fileno(stdin);
int fprintf(FILE *f, const char *formato[arg,...]);
Funciones relacionadas: fdopen, fopen.
Imprime datos con formato en un flujo.
FILE *fopen(const char *f, const char *modo); Funciones relacionadas: cprintf, fscanf, printf, putc, sprintf.
Abre un archivo f. La cadena de caracteres modo especifica el tipo de
acceso.
fputc #include <stdio.h>
Modo Acción
int fputc(int c, FILE *f);
“r” Abre para lectura.
“w” Abre un archivo vacío para escritura. Escribe un carácter c en el flujo abierto para salida con buffer.
“a” Abre para escritura al final del archivo (añadir).
“r+” Abre para lectura/escritura. fputc(*(p++), stdout);
“w+” Abre un archivo vacío para lectura/escritura.
“a+” Abre para lectura y añadir. Funciones relacionadas: fgetc, fgetchar, fputchar, getc, get-
“rb” Abre un archivo binario para lectura. char, putc.
“wb” Crea un archivo binario para escritura.
“ab” Abre un archivo binario para añadir.
“rb” Abre un archivo binario para lectura/escritura.
fputchar #include <stdio.h>
“wb” Crea un archivo binario para la lectura/escritura.
“ab” Abre o crea un archivo binario para lectura/escritura.
int fputchar(int c);
apenf.qxd 26/11/99 14:17 Página 641
Funciones relacionadas: fgetc, fgetchar, gputc, getc, getchar. Funciones relacionadas: csanf, fprintf, scanf, sscanf.
int fputs(const char *cad, FILE *f); int fseek(FILE *f, long desp, int org);
Escribe una letra cad en un flujo f. Devuelve el último carácter impre- Mueve el puntero del archivo asociado con f a una nueva posición que
so, si hay error devuelve EOF. está desplazada desp bytes de org.
Funciones relacionadas: fwrite, read. int fsetpos(FILE *f, const fpos_t *p);
int fscanf(FILE *f, const char *formato [, dirección,...]); Funciones relacionadas: fgetpos, fssek, tell.
apenf.qxd 26/11/99 14:17 Página 642
fwrite #include <stdio.h> Devuelve el siguiente carácter de stdin. Si se alcanza el final de archi-
vo, se devuelve EOF.
size_t fwrite(const void *p, size_t l, size_t n, FILE *f);
int c;
Escribe n elementos (registros) de longitud l desde la memoria apunta- while((c = getchar())!= ´\n´)
da por p al archivo f. Devuelve el número de caracteres realmente escritos printf(“%c”, c);
que, si la función tiene éxito, es igual al número indicado.
Funciones relacionadas: fgetc, fgetchar, getch, getche, putc,
num = fwrite(lista, sizeof(char),25,flujo); putchar, ungetc.
Funciones relacionadas: getchar, fgetc, fputc, fputchr, putc, char *gets(char *cad);
putchar, fopen.
Lee una línea desde el archivo de entrada estándar stdin, por omisión
es el teclado y lo guarda en cad.
getch #include <stdio.h>
gets(nombre);
int getch(void)
Funciones relacionadas: fgets, fputs, puts.
Lee un carácter del teclado sin hacer eco en la pantalla.
do {
car = getch();
char = toupper(car); getw #include <sdio.h>
} while(car != ´S´);
int getw(FILE *f);
Funciones relacionadas: cgets, fgetc, getc, getchar, ungetch.
Lee un entero (o una palabra de dos bytes) de un flujo f.
putc, putchar #include <stdio.h> Reinicializa el puntero del archivo al principio de un flujo.
Código Formato
putch #include <stdio.h>
%c Carácter.
%d Entero decimal.
int putch(int c);
%x Hexadecimal.
%i Entero decimal.
Escribe un carácter en la pantalla.
%f Número real.
%o Octal.
putch(´B´);
%p Puntero.
%s Cadena.
Funciones relacionadas: putc, putchar.
apenf.qxd 26/11/99 14:17 Página 644
scanf(“%d %f %c %s”, &i, &fp, &c, s); Esta función es idéntica a scanf, excepto que los datos son leídos del
array apuntado por b, en vez de stdin.
Funciones relacionadas: fscanf, printf, sscanf, vfprintf,
vprintf, vsprintf sscanf(buffer, “%,s%s”,uno,dos,tres);
int setvbuf(FILE *f, char *b, int t, size_t l); tmpnam #include <stdio.h>
Asigna el buffer b de tamaño l y el tipo t con el flujo (archivo) f. Los char *tmpnam(char *s);
valores correctos de t son: _IOBF, _IONBF e _IOLBF.
Genera un único nombre de archivo y lo guarda en el array apuntado por s.
setvbuf(demo, buffer, _IOFBF, 120);
tmpnam(prueba);
Funciones relacionadas: setbuf.
Funciones relacionadas: tmpfile.
int sscanf(const char *b, const char *f[,dirección,...]); int ungetch(int ch);
apenf.qxd 26/11/99 14:17 Página 645
vfprintf, #include <stdio.h> Funciona igual que sscanf, excepto que en vsscanf es utilizado un
vprintf, #include <stdarg.h> puntero a una lista de variables en lugar de a las propias variables.
vsprintf
vsscanf(buf_en, formato_p, arg_p);
int vfprintf(FILE *f, const char *f, lista_va lista_arg);
int vprintf(const char *f, lista_va lista_arg); Funciones relacionadas: fscanf, sscanf, scanf, vfscanf, vscanf.
int vsprintf(char *b, const char *f, lista_va lista_arg);
Escribe salida con formato utilizando un puntero a una lista de argu- Funciones de bajo nivel
mentos.
Las declaraciones de las funciones de bajo nivel se incluyen en los archivos
vprintf(formato, nota); de cabecera io.h, fcntl.h, sys|types.h y sys|sta.h. A diferencia de
las funciones stream, las funciones de bajo nivel no requieren el archivo de
Funciones relacionadas: fprintf, printf, sprintf, va_arg, inclusión stdio.h.
va_end, va_strat.
Lee entrada con formato de un flujo, tal como scanf, excepto que vfs- Cierra el archivo especificado en h. Estas funciones se utilizan con
canf acepta un puntero a la lista de argumentos. _open y open.
Funciones relacionadas: fscanf, scanf, sscanf, vscanf, vsscanf. Funciones relacionadas: fclose, fopen, open.
Indicador
dup, dup2 #include <io.h> Significado
Lectura/escritura
int dup(int h); O_RDONLY Abrir para lectura.
int dup2(int h1, int h2); O_WRONLY Abrir para escritura.
O_RDWR Abrir para lectura y escritura.
Crea un segundo enlace a un archivo abierto (dup) o reasigna un enlace O_NDELAY Pone el puntero del archivo al final del archivo.
de archivo (dup2). O_APPEND Se crea el archivo y se fijan atributos del archivo.
O_TRUNC Trunca el archivo a 0.
viejostdout = dup(STDOUT);
O_EXCL Se utiliza con O_CREAT.
dup2(fptr, STDOUT);
O_BINARY Abrir archivo en modo binario.
O_TEXT Abrir archivo en modo texto.
Funciones relacionadas: close, creat, open.
apenf.qxd 26/11/99 14:17 Página 647
open(“OPEN.OUT”, 0_WRONLY|O_CREAT, S_IREAD|IWRITE); Devuelve la posición actual del puntero del archivo especificado por d.
if((h = open(“open.tst”, O_CREAT))==1)...
posi = tell(desf);
Funciones relacionadas: access, chmod, close, creat, fopen.
Funciones relacionadas: ftell, lseek.
\n se interpreta como avance de línea (LF) y \r se debe utilizar para indicar getpass #include <conio.h>
un retorno de carro (CR).
char *getpass(const char *indicador);
cprintf(“Cubo de %2d es %rd\r\n”,i, i * i * i);
Lee una palabra de paso por consola, que no se visualiza en pantalla
Funciones relacionadas: printf. (menos de ocho caracteres de longitud).
Escribe una cadena en la pantalla. No se envía ningún carácter de nueva inport, inportb #include <dos.h>
línea después de la cadena.
int inport(int puerto);
cuts(“Está usted seguro(s/n)?”); unsigned char inportb(int puerto);
Funciones relacionadas cprintf. Lee una palabra de 16 bits (inport) o un byte (inportb) de un puerto
de E/S especificado por puerto.
La función inport es útil para leer dos puertos adyacentes a la vez, e
inportb para controlar dispositivos de entrada/salida.
cscanf #include <conio.h>
palabra = inport(PORT_8259_20);
int cscanf(char *formato [,dirección,...]); P21 = inportb(PORT_8259_21);
Lee caracteres con formato directamente desde la consola en la posición Funciones relacionadas: outport, poutportb.
dada por dirección.
Escribe una palabra de 16 bits (outport) un byte (outportb) en un Verifica si existe un archivo y, en caso afirmativo, los permisos de acce-
puerto de E/S. so al archivo.
int access(const char *nomarch, int modo); Funciones relacionadas: access, chmod, fstat, stat.
apenf.qxd 26/11/99 14:17 Página 650
Crea un nombre de camino completo (letra, unidad, camino directorio, Funciones relacionadas: access, chmod, stat.
nombre de archivo y extensión del archivo). En Microsoft, la función equi-
valente es _makepath.
fnmerge(camino,”C:”,\\aux,”resultado”,”.dat”);
isatty #include <io.h>
// nombre de camino”C:\aux\resultado.dat”
int isatty(int h);
Funciones relacionadas: fnsplit.
Determina si es un dispositivo orientado a carácter (terminal, consola,
impresora o puerto serie).
fnsplit #include <dir.h>
if(isatty(fileno(stdout)))
int fnsplit(const char *camino, char *unidad, puts(“es consola”);
char *dir, char *fnombre, char *ext);
f = fnsplit(c, unidad, dir, arch, ext); int lock(int h, long d, long n);
Funciones relacionadas: fnmerge. 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.
Crea un único nombre de archivo modificando una plantilla dada como Funciones relacionadas: fopen, open.
argumento, plantilla toma la forma basexxxxxx, donde base es el nom-
bre que se proporciona y x los caracteres a modificar.
stat #include <sys\stat.h>
char modelo = “tcbxxxxxx”;
int stat(char *f, struct stat *buffer);
mktemp(modelo);
Obtiene información sobre el estado de un archivo existente f.
Funciones relacionadas: tmpfile, tmpnam.
resultado = stat(“stat.c”,&buf);
Permite cambiar el modo del archivo abierto entre texto y binario. Funciones relacionadas: remove.
apenf.qxd 26/11/99 14:17 Página 652
unlock #include <conio.h> Las funciones complejas son propias de Borland C++ y no son expor-
tables.
int unlock(int h, long o, long l);
Clase bcd
Desbloquea una sección del archivo h que ha sido bloqueada con lock.
La clase bcd permite manipular números almacenados en notación decimal
unlock(m,OL,256); // desbloquea 256 bytes codificado a binario (BCD) y proporciona hasta 17 dígitos decimales de
precisión, y un rango de 1 × 10-125 a 1 × 10125.
Funciones relacionadas: lock, sopen.
La función arg() devuelve el ángulo, en radianes, de un número en el Calcula el arco tangente de y/x. El resultado es un ángulo de valor
plano complejo. comprendido entre –π y π radianes.
double atan(double x); Calcula (redondea) el número entero mayor que o igual a x.
_control87 #include <float.h> La función div() calcula el cociente entero y el resto de x por y. La
función devuelve una estructura div_t definida en stdlib.h como
unsigned int _control87(unsigned int nuevo, unsigned int
mascara); typedef struct
{
int quot; // cociente
Obtiene y establece la palabra de control de coma flotante. Cuando se int rem; // resto
utiliza un coprocesador matemático 8087, _control87 establece su palabra } div_t;
de control.
div_t resultado;
estado = control87(PC24,MCW_IC); resultado = div(35, 8);
// precisión 24 bits // resultado.cociente = 4, resultado.resto = 3
Funciones relacionadas: _clear87, _status87.
Calcula el coseno del argumento x. El argumento x se especifica en Calcula el exponencial de x:ex; donde e es la base del logaritmo natu-
radianes y devuelve un valor en el rango de –1 a 1. ral (e = 2.7182818).
coseno_x = cos(1.6543); x = 100.00;
y = exp(x);
Funciones relacionadas: acos, sin. printf(“El exponencial de x = %f.\n”,y);
Calcula el resto de la división real x por y. Calcula la hipotenusa de un triángulo rectángulo cuyos lados son x e y.
Una llamada a hypot equivale a lo siguiente:
resto = (fmod(5.0, 2.0); // resto igual a 1.0
sqrt(x * x, y * y);
Funciones relacionadas: floor.
double x = 3.0; y = 4.0;
printf(“%lf”, hypot(x, y));
ldesp, ldespl #include <math.h> stderr, la variable global errno toma el valor EDOM y devuelve el valor
HUGE_VAL. Si x es 0, la función imprime un mensaje de error SING en
double ldesp(double x, int exp); stderr, devuelve el valor HUGE_VAL y fija errno a ERANGE.
long double ldexpl(long double x, int exp);
hdouble x, y;
x = 10;
Calcula y devuelve el valor real de x*eexp. y = log(x);
y = log10(x);
double x = 4.0,y;
int p = 5;
y = ldexp(x, p); Funciones relacionadas: exp, matherr pow.
ldiv_t ldiv(long int x, long int y); 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-
Calcula el cociente y el resto de la división x/y. La función ldiv nifica que el bit más a la izquierda sale fuera y se inserta en su posición el
devuelve una estructura de tipo ldiv_t que comprende el cociente y el siguiente bit de mayor peso, y los restantes bits se desplazan una posición a
resto. la izquierda.
Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x. int matherr(struct exception *e);
Si x es negativo, ambas funciones devuelven un error de dominio DOMAIN en int _matherrl(struct _exception1 *e)
apenf.qxd 26/11/99 14:17 Página 657
Esta función manipula errores matemáticos. Las funciones matemáticas polar #include <complex.h>
llaman a la rutina adecuada matherr cuando se detecta un error. Se puede
desarrollar su propia versión de matherr para personalizar su tratamiento complex polar(double modulo, double angulo);
de errores. Para profundizar en esta función, consultar su referencia en
Library Reference de Borland C++ (págs. 352-353). Devuelve un número complejo con una magnitud (módulo) y ángulo
dado.
Funciones relacionadas: Las funciones matemáticas.
complex < = complex(x, y);
Devuelve el mayor de dos valores. Ambos argumentos y la declaración Funciones relacionadas: Sólo existe en C+.
de la función deben ser del mismo tipo.
double dbl1, dbl2, dblmax; poly #include <math.h>
dblmax = max(dbl1, dbl2);
double poly(double x, int n, double c[]);
Funciones relacionadas: min.
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 para
min #include <stdlib.h> evaluar el polinomio es:
(tipo) min(a, b); c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]
Devuelve el menor de dos valores. Ambos argumentos y la declaración
// polinomio: 3x**2 + 2x + 1//
de la función deben ser del mismo tipo.
double c[] = {-10.0,2,c);
int i1, i2, minent;
minent = min(i1, i2); Funciones relacionadas: pow.
Funciones relacionadas: max.
rand #include <stdlib.h>
double modf(double x, double *partent); Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; esta
long double modfl(long double x, long double *partent); constante 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.
La función modf divide un número de coma flotante en dos partes, ente-
Para obtener un número en el rango de 0 a (n-1) hay que utilizar random.
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. // visualizar 10 números aleatorios //
for(i = 0; 1 < 10; i++)
pardecimal = modf(36.95, &parte_entera(;
// parte entera 36, parte decimal .95 printf(“%6d\”, rand());
modelo_nuevo = _rotl(0x1234,8);
int random(int x);
// resultado es 3412h
Genera un número pseudoaleatorio en el rango de 0 a x-1.
Funciones relacionadas: _lrotl, _rotr, _rotr.
// obtener un número aleatorio entre 0 y 20
numa1 = random(21);
_rotr #include <stdlib.h>
Funciones relacionadas: rand, randomize.
unsigned _rotr(unsigned x, int c);
Funciones relacionadas: rand, random, srand. La función sin() proporciona el seno de x (se supone en radianes).
double x, y;
real #include <complex.h> x = 0.52;
#include <bcdh.h> printf(“x = %f radianes\n”, x);
y = sin(x)
printf(“el seno de x = %f\n”, y);
double real(complex x);
double real(bcd x); Funciones relacionadas: asin, cos, sinh.
Devuelve la parte real de un número complejo x o convierte un número
BCD a float, double o long double. sinh #include <math.h>
#include <complex.h>
complex z = complex(x, y)
cout << “parte real:” << real(z) << “\n”;
double sinh(double x);
complex sinh(complex x);
Funciones relacionadas: Función exclusiva de C++.
Devuelve el seno hiperbólico de x (x, se supone en radianes).
_rotl #include <stdlib.h> y = sinh(x);
Funciones relacionadas: atan. void *memchr(const void *buf, int c, size_t n);
apenf.qxd 26/11/99 14:17 Página 660
Busca un carácter específico c en un buffer (buf) examinando los n pri- memmove #include <string.h>
meros caracteres. #include <mem.h>
result = memchr(direc, ´I´, 40);
void *memmove(void *dest, const void *f, size_t n);
Funciones relacionadas: memcmp, memicmp.
Mueve n bytes de un buffer (f) a otro (dest).
resultado = memcmp(buf1, buf2, sizeof(buf1)); Funciones relacionadas: memccpy, memcpy, memmove, movemem, setmem.
Funciones relacionadas: memicmp.
movedata #include <mem.h>
#include <string.h>
memcpy #include
void movedata (unsigned ss, unsigned so,
void *memcpy(void *dest, const void *fuente, size_t n); unsigned ds, unsigned do, size_t n);
Copia n bytes de fuente en dest. Devuelve un puntero a dest.
Mueve n bytes desde ss a ds, donde ss es el segmento fuente, so es el
memcpy(dest, fuente, 80): desplazamiento fuente, ds es el segmento destino, do es el desplazamiento
destino y n es el número de bytes que hay que mover.
Funciones relacionadas: memccpy, memmove, movedata.
movedata(seg1, off, seg2, dest_off, 4096);
int memicmp (const void *b1, const void *b2, size_t n); movmem #include <mem.h>
Compara un número de bytes de un buffer (b1) con otro (b2) sin hacer void movmem(void *fuente, void *destino, unsigned n);
caso del tamaño de las letras en los dos buffers.
Copia n bytes de fuente a destino.
if(memicmp(buf1, buf2, 15) == 0)
puts(“Los buffers son iguales en los 15 primeros bytes \n”); movmem(&fuente[6], fuente, sizeof(fuente));
Fija un bloque de long bytes en el buffer dest al carácter c. setmem es Borra la ventana actual y pone el cursor en la esquina superior izquier-
útil para inicializar buffers. da (1,1).
Copia un número par de bytes de una posición a otra, intercambiando al Borra la línea completa que contiene el cursor y desplaza hacia arriba
mismo tiempo cada par de bytes adyacentes. las líneas que haya debajo.
F.14. FUNCIONES DE PRESENTACIÓN DE TEXTO int gettext(int izda, int arriba, int derecha, int abajo,
void *textbuf);
Las funciones de presentación de texto permiten definir coordenadas de una
ventana de texto en la pantalla y manipular texto. Con estas funciones se Copia el contenido de un área rectangular de la pantalla al buffer cuya
puede posicionar texto en cualquier parte de la pantalla, seleccionar atribu- dirección se da en el argumento textbuf. Todas las coordenadas son abso-
tos de texto (tales como subrayado, vídeo inverso, parpadeo, colores de lutas.
fondo y primer plano), así como actuar sobre ventanas de texto. Estas fun-
ciones se encuentran esencialmente en el archivo de cabecera conio.h. if(!gettext(1,1,30,20, pan_grabada))
puts(“color”);
void clreol(void);
gettextinfo #include <conio.h>
Borra la línea actual desde la posición del cursor al final de la línea.
void gettextinfo(struct text_info *r);
clreol()
Devuelve información relativa a las coordenadas de la ventana actual,
Funciones relacionadas: clrscr, delline, textbackground, window. posición del cursor dentro de la ventana, atributo del texto, las dimensiones
apenf.qxd 26/11/99 14:17 Página 662
de la pantalla y el modo de texto actual. La información se devuelve en una Inserta una línea en blanco en la ventana de texto actual en la posición
estructura text_info. del cursor, desplazando el resto de las líneas situadas debajo.
Funciones relacionadas: wherex, wherey, window. if (!movetext(1, 1, 30, 20, 40, 40))
puts(“victoria”);
void highvideo(void);
normvideo #include <conio.h>
Activa caracteres de alta intensidad.
void normvideo(void);
highvideo();
Reinicializa los atributos de texto al valor que tenían antes de que arran-
Funciones relacionadas: lowvideo, normvideo, textcolor. que el programa.
normvideo();
insline #include <conio.h>
Funciones relacionadas: highvideo, lowvideo, textattr, textco-
void insline(void); lor.
apenf.qxd 26/11/99 14:17 Página 663
int puttext(int izda, int arriba, int dcha, int abajo, void textbackground(int colorfondo);
void *textbuf);
Establece el color de fondo para texto vidualizado.
Copia el contenido de un buffer en una zona rectangular de la pantalla
en modo texto.
textbackground(2);
puttext(3, 1, 32, 22, buffertexto);
_setcursortype #include <conio.h> Establece el color del primer plano del texto visualizado por cprintf y
cputs. El argumento puede tomar un valor entre 0 BLACK (negro) y 15
void setcursortype(int estilo_cursor); WHITE (blanco).
Cambia la forma del cursor en modo texto. El argumento tiene que ser textcolor(15);t
una de las constantes.
Funciones relacionadas: textattr, textbackground.
_NOCURSOR Desactiva el cursor.
_SOLIDCURSOR Un carácter bloque sólido es el cursor.
_NORMALCURSOR Un subrayado parpadeante es el cursor.
setcursortype(_SOLIDCURSOR); texmode #include <conio.h>