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 archivos permiten establecer y verificar permisos de acceso a archivos. La mayoría de las funciones están en el archivo de cabecera io.h, y las restantes en sys|stat.h, dir.hystdio.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);
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 de tipostatapuntada por buffer. La estructura states:
struct stat {
short st_dev; // unidad o dispositivo short st_ino; // número inodo (UNIX) short st_mode // modo archivo
short 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 UNIX
long st_size; // tamaño archivo en bytes long st_atime; // hora último acceso long 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 ndel 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.
mktemp #include <dir.h> char * mktemp(char *plantilla);
Crea un único nombre de archivo modificando una plantilla dada como argumento, plantillatoma la forma basexxxxxx, donde basees el nom- bre que se proporciona y xlos 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 vnann. 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 open ycreate.
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”);
unlock #include <conio.h> int unlock(int h, long o, long l);
Desbloquea una sección del archivo hque ha sido bloqueada con lock. unlock(m,OL,256); // desbloquea 256 bytes
Funciones relacionadas: lock, sopen.
F.12. FUNCIONES MATEMÁTICAS
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álculo científico. Sin embargo, desde la normalización de ANSI C y su extensa biblioteca matemática, C se ha convertido en un fuerte rival del lenguaje científico por excelencia, FORTRAN. C soporta operaciones de coma flo- tante e incluye también un rico conjunto de funciones matemáticas. Borland C++ 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íficas importantes: complex y bcd, se encuentran en los archivos complex.hy bcd.h, respectivamente.
Clase complex
Borland C++ incluye una estructura complex en el archivo de cabecera math.h, cuyos miembros son la parte real e imaginaria de un número com- plejozy que se define así:
struct complex {
double x; // parte real del número complejo double y; // parte imaginaria del complejo }
Se puede declarar e inicializar un número complejo (x + yi) de esta forma:
struct complex z = {1.5,1.5} // z = 1.5 + i1.5;
Las funciones complejas son propias de Borland C++ y no son expor- tables.
Clasebcd
La clase bcdpermite manipular números almacenados en notación decimal codificado a binario (BCD) y proporciona hasta 17 dígitos decimales de precisión, y un rango de 1 ×10-125a 1 ×10125.
abs versiónreal #include <math.h> #include <stdlib.h> versióncompleja #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 el archivo de cabecera complex.h.
x = abs(-7) // x es 7
Funciones relacionadas:cabs, fabs, labs.
acos #include <math.h>
#include <complex.h> double acos(double x);
complex acos(complex x);
La función acos()devuelve el arco coseno de x, cuyo valor debe estar en el rango –1 a 1. El resultado es un valor (ángulo) entre 0 y /radianes. angulo = acos(0.5); // el ángulo devuelto es //3 Funciones relacionadas: cos, matherr.
arg #include <complex.h>
La función arg()devuelve el ángulo, en radianes, de un número en el plano complejo. complex z; double angulo; z = complex(1.5, 4.5); angulo = arg(z);
Funciones relacionadas: complex, norm, polar.
asin versiónreal #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 xdebe 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 xes –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 valor comprendido entre –/y/radianes.
angulo = atan2(y, x);
Funciones relacionadas: atan, matherr, tan.
cabs #include <math.h>
double babs(struct complex z);
Calcula el valor absoluto de un número complejo almacenado en una estructura de tipo complex.
struct complex z; double complejo; z.y = 3.5
z.y = 2.4
complejo = cabs(z);
printf(“valor absoluto %lf\n”, complejo);
Funciones relacionadas: fabs, hypot, matherr, sqrt.
ceil #include <math.h>
double ceil (double x);
Calcula (redondea) el 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();
_control87 #include <float.h> unsigned int _control87(unsigned int nuevo, unsigned int mascara);
Obtiene y establece la palabra de control de coma flotante. Cuando se utiliza un coprocesador matemático 8087, _control87establece su palabra de 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 en radianes y devuelve un valor en el rango de –1 a 1.
coseno_x = cos(1.6543);
Funciones relacionadas: acos, sin.
cosh #include <math.h>
double cosh(double x); complex cosh(complex x);
Calcula el coseno hiperbólico de la variable x. Si el argumento pasado acosh()es demasiado grande, se produce un error de rango.
x = 1.00
printf(“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 pory. La función devuelve una estructura div_tdefinida en stdlib.hcomo typedef struct
{
int quot; // cociente int rem; // resto } div_t;
div_t resultado;
resultado = div(35, 8);
// resultado.cociente = 4, resultado.resto = 3
exp #include <amth.h>
#include <complex.h>
double exp(double x); complex exp(complex x);
Calcula el exponencial de x:ex; donde ees 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>
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 xpory.
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 utilizarse después de las llamadas a las funciones system(), exec(), span()sobre má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 frexpdescompone el valor xen una mantisa (m) y en un exponenten, tal que el valor absoluto de mes mayor o igual a 0,5 y menor que 1,0 y x + m*2n. La mantisa se obtiene por la función, y el exponente se almacena en la variable apuntada por exp.frexpldescompone un valor long double.
double x, y; int n; x = 17.5;
y = frexp(x, &n);
printf(“frexp(%f, &n) = %f, n = %d\n”,x,y,n);
Funciones relacionadas: exp, ldexp, modf.
hypot #include <math.h>
double hypot(double x, double y);
Calcula la hipotenusa de un triángulo rectángulo cuyos lados son xey. Una llamada a hypotequivale 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 no es transportable.
double x = 3.4, y = 4.5; complex = complex(x, y);
cout << “parte imaginaria:” << imag(z) << “\”;
Funciones imaginarias: complex, conj, real.
labs #include <math.h>
long int labs(long int n);
Calcula el valor absoluto de un entero largo (n). long lx = –51654L, ly;
ly = labs(lx);
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 ldiv devuelve una estructura de tipo ldiv_tque comprende el cociente y el resto. typedef struct { long quot; long rem; } ldiv_t; long x = 5258625, y = 341654; ldiv_t resultado;
resultado = ldiv(x, y);
printf(“el cociente y el resto es %ld, %ld,\n”, resultado.quot, resultado.rem);
Funciones relacionadas: div.
log, log10 #include <math.h>
#include <complex.h>
double log(double x); double log10(double x);
Calcula el logaritmo natural (neperiano) y el logaritmo en base 10 de x. Sixes negativo, ambas funciones devuelven un error de dominio DOMAINen
stderr, la variable global errnotoma el valor EDOMy devuelve el valor HUGE_VAL. Si x es 0, la función imprime un mensaje de error SING en stderr,devuelve el valor HUGE_VALy fija errnoaERANGE.
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 _lrotlpara 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 el siguiente bit de mayor peso, y los restantes bits se desplazan una posición a la izquierda.
unsigned long x = 0x0fac45491;
printf(“x desplazado 4 veces es”, _lrotl (x, 4);
Funciones relacionadas: _lrotr, _rotl, _rotv.
_lrotr #include <stdlib.h>
unsigned long _lrotr(unsigned long x, int c);
Rota a la derecha los bits de x. Rotación a derecha de un bit significa salir fuera el bit de menor peso y los restantes se desplazan una posición a la derecha.
val_r = _lrotr(x, 4);
Funciones relacionadas: _lrotl, _rotl, _rotr.
matherr #include <math.h>
_matherrl
int matherr(struct exception *e); int _matherrl(struct _exception1 *e)
Esta función manipula errores matemáticos. Las funciones matemáticas llaman a la rutina adecuada matherrcuando se detecta un error. Se puede desarrollar su propia versión de matherrpara personalizar su tratamiento de errores. Para profundizar en esta función, consultar su referencia en Library Referencede 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ón de 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ón de 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 modfdivide un número de coma flotante en dos partes, ente- ra y decimal. La parte entera de xse 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 ángulo dado.
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 polypara evaluar un polinomio en x, de grado ny cuyos coe- ficientes son los correspondientes al array c. La expresión utilizada para evaluar el polinomio es:
c[n]xn+c[n-1]n-1+...+c[2](x2+c[1](x+c[0]
// polinomio: 3x**2 + 2x + 1// double c[] = {-10.0,2,c);
Funciones relacionadas: pow.
rand #include <stdlib.h>
int rand(void);
Genera un número pseudoaleatorio en el rango de 0 a RAND_MAX; esta 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. 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());
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 20 numa1 = random(21);
Funciones relacionadas: rand, randomize.
randomize #include <stdlib.h>
#include <time.h>
void randomize(void);
Inicializa (genera una semilla) el generador de números pseudoaleato- rios con una semilla aleatoria que es función de la hora actual. Esta función impide 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 xo convierte un número BCD a float,doubleolong 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,cbits 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 _rotrpara rotar a la derecha el valor de x,cbits. _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);
sqrt #include <math.h> double sqrt(double x);
complex sqrt(complex x);
Calcula la raíz cuadrada de un número xno negativo. printf(“%lf”,sqrt(25.0); // se visualiza 5
Funciones relacionadas: exp, log, pow.
srand #include <stdlib.h>
void srand(unsigned x);
srandinicializa el generador de números aleatorios con la semilla x. Si xes 1, el generador se reinicializa; cualquier otro valor de xfija 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 dex(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.