CAPITULO 9: BIBLIOTECAS DE

FUNCIONES

El lenguaje C, C++ contiene numerosas funciones, cuando se emplean

funciones de esta biblioteca estandar, se incrementa la transportabilidad de los
programas.

Las funciones estandar se dividen en grupos, todas las funciones que

pertenecen al mismo grupo estan declaradas en el archivo de cabecera (aquel
que dice xxx.h), la letra "h" significa header en inglés y es lo que se llama
cabecera.

Para incluir alguna función perteneciente a estas cabeceras debemos escribir

líneas de código como se muestra de ejemplo:

#include

He disenado esta tabla para que estudiemos las bibliotecas de funciones,

obviamente son las que he encontrado en mis libros y sistemas.
 

BIBLIOTECAS Y DESCRIPCIONES DE USO

Nombre de
Descripcion
Biblioteca

Es proporcionar una definicion de la macro assert, que imprime

assert.h
un mensaje de error y aborta el programa

Existen funciones para asignar, liberar memoria, u obtener

alloc.h
informacion de bloques de memoria.

Son funciones que nos permiten conocer la naturaleza de un

ctype.h caracter, o bien para convertir de mayusculas a minusculas y
viceversa; y valores enteros a codigos ASCII.

Esto permite ordenar, crear, modificar, mover y eliminar

dir.h
directorios

Representa los numeros de error, despues que ocurre un error se

errno.h puede consultar el valor de la varianble del sistema deerrno para
obtener mas informacion sobre ese error.
 float.h Define los limites de los tipos de coma flotante

limits.h Define los limites de los diferentes tipos de enteros

Contiene las funciones matematicas estandar utilizadas en C y C+

math.h
+

setjmp.h Define el tipo de jmp_buf para algunas funciones.

signal.h Contiene funciones de estado.

Define funciones que pueden ser llamadas con diferentes

stdarg.h numeros de argumentos, de modo que se pueda escribir f(a) y
f(a,b).

stdef.h Se definen algunos tipos especiales

Incorporan las funciones de Entrada - Salida E/S estandar, tipos y

stdio.h
macros

Declara funciones que son utiles para diferentes propositos, en

stlib.h
especial de busqueda y ordenacion.

Este archivo contiene funciones para manejo de cadenas de

string.h
caracteres.

time.h Contiene funciones relativas a fechas y horas

Funciones Encontradas en las Bibliotecas

Bibliot
Nomb
eca a
re de
# Tipo  la cual Sintaxis Descripción Ejemplo
funció
perten
n
ece

Devuelve el valor
1 abs(i) int stdlib.h int abs(int i); x = abs(-7) // x es 7
absoluto de i

double Devuelve el arco angulo = acos(0.5); //

2 acos(d) double math.h
acos(double d); coseno de d angulo devuelto es phi/3

double Devuelve el arco angulo = asin(0.707); //

3 asin(d) double math.h
asin(double d); seno de d aproximadamente phi/4

4 atan(d) double math.h  double Devuelve la arco angulo atan(1.0); // angulo

 tangente de d.
Calcula el arco
atan(double d); tangente del
long double argumento x.
es phi/4
tanl(long double Requiere el
d); llamado de la
biblioteca
complex.h

double Devuelve el arco

atan(d1
5 double math.h atan(double d1, tangente de angulo = atan(y, x)
, d2)
double d2); d1/d2

Convierte la
double x;
cadena s a una
char *cad_dbl =
double cantidad de
"200.85"; ...
6 atof(s) double stdlib.h atof(const char doble precisión.
x=atof(cad_dbl); //
*cadena) Requiere el
convierte la cadena
llamdo de la
"200.85" a valor real
biblioteca math.h

Convierte la
cadena s a un
entero. 
La cadena debe int i;
tener el siguiente char *cad_ent="123";
int atoi(const formato: ...
7 atoi(s) int stdlib.h
char *cadena) [espacio en i=atoi(cad_ent); 
blanco][signo] //convierte la cadena
[ddd] (siendo "123" al entero 123
obligatorio los
digitos
decimales).

8 atol(s) long stdlib.h long atol(const Convierte la long int i;

char *cadena); cadena s a un char cad_ent="9876543";
entero largo. ...
La cadena debe i=atol(cad_ent); 
tener el siguiente //convierte la cadena
formato: "9876543" al entero largo
[espacio en
blanco][signo]
[ddd] (siendo
obligatorio los
digitos
 decimales).

Reserva memoria
para una
formación de n
elementos , cada
uno de s bytes.
malloc.
Devuelve un
hy
puntero al
stdlib.h void long *buffer
calloc(n void(pun principio del
9 o bien *calloc(size_t n, buffer=(long *) calloc(40,
, s) tero) espacio
alloc.h y size_t s); sizeof(long));
reservado.
Si no existente
stdlib.h
bastante espacio
para el nuevo
bloque o bien n o
s es 0, calloc
devuelve nulo.

Devuelve un
valor
1 double redondeado por redondeo=ceil(5.1);
ceil(d) double math.h
0 ceil(double d); exceso al //redondeo es 6
siguiente entero
mayor

double
1 cos(double d); Devuelve el
cos(d) double math.h coseno_x=cos(1.6543)
1 complex coseno de d
cos(complex d);

double
Devuelve el
1 cos(double d); d=1.00;
cosh(d) double math.h coseno
2 complex printf("d=%f.\n\n,d);
hiperbólico de d
cos(complex d);

1 difftim double time.h double Devuelve la time_t inicio, fin;

3 e(11, difftime(time_t diferencia de clrscrl();
12) hora2, time_t tiempo 11(hora2) inicio=time(NULL);
hora1) - 12(hora1) , delay(5000)
donde 11 y 12 fin=time(NULL)
representan el print("Diferencia en
tiempo segundos: %f\n",
transcurrido difftime(inicio,fin));
despues de un
tiempo base (ver
 función time)

Cierra todos los

archivos y buffers
y termina el
programa. El
1 void exit(int
exit(u) void stdlib.h valor de u es exit(0);
4 estado)
asignado por la
funcion para
indicar el estado
de terminación.

Eleve e a la
potencia d
double (e=2,7182818... d=100.00;
1 exp(double d); es la base del y=exp(d);
exp(d) double math.h
5 complex sistema de printf("El exponencial de
exp(complex d) logaritmos x=%f.\n\n",y);
naturales
(neperianos))

1 double Devuelve el valor y=fabs(-7.25); // y vale

fabs(d) double math.h
6 fabs(double d); absoluto de d 7.25

Cierra el archivo
f. Devuelve el
1 fclose(f int fclose(FILE valor 0 si el
int stdio.h int fclose(FILE "archivo");
7 ) *f); archivo se ha
cerrado con
exito.

Determina si se
ha encontrado
un fin de archivo.
1 si es asi,
feof(f) int stdio.h int feof(FILE *f); feof(fichen);
8 devuelve un
valor distinto de
cero, en otro
caso devuelve 0

1 Lee un caracter
fgetc(f) int stdio.h int fgetc(FILE f); c+fgetc(fp)
9 del archivo f

2 fegts(s, char(pun stdio.h char *fgets(char Lee una cadena fgets(caddemo, 80, fp);
0 i, f) tero) s, int s, FILE *f); s, con i
caracteres, del
 archivo f

Devuelve un
valor
2 double redondeado por
floor(d) double math.h x=floor(6.25); // x vale 6
1 floor(double d); defecto al entero
menor mas
cercano

Devuelve el resto
double
2 fmod(d de d1/d2 (con el resto=fmod(5.0,2.0); //
double math.h fmod(double d1,
2 1, d2) mismo signo que resto igual a 1.0
double d2);
d1)

2 fopen(s file(punt stdio.h FILE Abre un archivo if

3 1, s2) ero) *fopen(const llamado s1, del ((corriente2=fopen("datos
char *s1, const tipo s2. Devuelve ","W+"))==NULL
char *s2) un puntero al printf("El archivo...no se ha
archivo. * abierto \n");
 

Mo
Accion
do

Abre para
"r"
lectura

Abre un
archivo
"w" vacio
para
escritura

Abre para
escritura
"a" al final
del
archivo

Abre para
"r+
lectura/e
"
scritura

"w Abre un
+" archivo
vacio
para
 lectura/e
scritura

Abre para
"a+
lectura y
"
anadir

Abre un
archivo
"rb
binario
"
para
lectura.

Abre un
archivo
"w
binario
b"
para
escritura

Abre un
archivo
"ab
binario
"
para
anadir

Abre un
archivo
"rb binario
+" para
lectura/e
scritura.

Abre un
archivo
"w binario
b+" para
lectura/e
scritura

Abre o
crea un
archivo
"ab
binario
+"
para
lectura/e
scritura
 int fprintf(FILE Escribe datos en
2 fprintf(f *f, const char el archivo f (el fprintf(f1, "El resultado es
int stdio.h
4 , ...) *formato resto de los %f\n",result);
[,arg,...]); argumentos

Escribe un
2 fputc(c, int fputc(int c,
int stdio.h caracter en el fputc(*(p++), stdout);
5 f) FILE *f);
archivo f

Escribe una
int fputs(const
2 fputs(s, cadena de fputs("esto es una
int stdio.h char *cad, FILE
6 f) caracteres en el prueba", f1);
*f)
archivo f

Lee i2 elementos,
size_t fread(void cada uno de
2 fread(s, fread(buf, strlen(msg)+1,
int stdio.h *b, size_t t, tamano i1 bytes,
7 i1, i2, f) 1, flujo);
size_t n, FILE *f); desde el archivo f
hasta la cadena s

char *cad; 
Libera un bloque // asignar memoria a la
malloc. de memoria cadena
2 void free(void
free(p) void ho reservada cuyo cad=(char *)malloc(50);
8 *dir_memoria);
stdlib.h principio esta ...
indicado por p. free(cad); // liberar
memoria

int fscanf(FILE Lee datos del

2 fscanf(f *f, const char archivo f ( el fscanf(flujo, %s%f, cad,
int math.h
9 , ...) *formato, [, resto de los &f);
direccion,... ]); argumentos

3 fseek(f, int stdio.h int fseek(FILE *f, Mueve el fseek(f1,OL,SEEK_SET); //

0 l, i) long desplaza, puntero al ir al principio
int origen); archivo f una
distancia de 1
bytes desde la
posicion i (i
puede
representar el
principio del
archivo, la
posicion actual
del puntero o el
fin del archivo. 
 Notas
 

Signific
Origen 
ado

Principi
SEEK_S
o de
ET
archivo

Posicio
n
SEEK_C
actual
UR 
punter
o 

Final
SEEK_E
del
ND 
archivo

Devuelve la
posicion actual
3 long int ftell(FILE
ftell(f) long int stdio.h del puntero ftell(fichen)
1 *f);
dentro del
archivo f

Escribe i2
size_t
elementos, cada
fwrite(s fwrite(const void
3 uno de tamano 1 num=fwrite(lista,sizeof(ch
, i1, i2, int stdio.h *p, size_t i1,
2 bytes, desde la ar),25,flujo);
f) size_t i2, FILE
cadena s hasta el
*f);
archivo f

while(c=getc(fx) !=EOF {
3 Lee un caracter
getc(f) int stdio.h int getc(FILE *f);    print ("%c",c);
3 del archivo f
}

Lee un caracter
int c;
desde el
3 getchar int while((*c=getchar()) !=
int stdio.h dispostivo de
4 () getchar(void); '\n')
entrada
   print ("%c",c);
estandar 

3 gets(s) char(pun stdio.h char *gets(char Lee una cadena gets(nombre);

5 tero) *cad); de caracteres
desde el
dispositivo de
 entrada estandar

Determina si el
carac=getch();
argumento es
if (isalnum(carac))
alfanumerico.
  print("%c letra|digito
3 isalnu int isalnum(int Devuelve un
int ctype.h \n",carac);
6 m(c) c); valor disitinto de
else
cero si es cierto;
  printf("%c no letra|
en otro caso
digito \n", carac);
devuelve 0

Determina si el
argumento es
alfabetico.
int c;
3 isalpha Devuelve un
int ctype.h int isalpha(int c); if (isalpha(c)) printf("%c es
7 (c) valor distinto de
letra\n",c);
cero si es cierto;
en otro caso
devuelve 0.

Determina si el
argumento es un
caracter ASCII.
int c;
3 isascii(c Devuelve un
int ctype.h int isascii(int c); if (isascii(c)) printf('%c es
8 ) valor disitinto de
un ascii\n",c)
cero si es cierto;
en otro caso
devuelve 0

Determina si el
argumento es un
caracter ASCII de
3 iscntrl( control. Devuelve if(iscntrl(c)) printf"%c es un
int ctype.h int isacntrl(int c);
9 c) un valor distinto caracter de control\n",c);
de cero si es
cierto; en otro
caso devuelve 0

4 isdigit(c int ctype.h int isdigit(int c); Determina si el if(isdigit(c)) printf"%c es un

0 ) numero es un digito\n",c);
digito decimal.
Devuelve un
valor disitinto de
cero si es cierto;
en otro caso
 devuelve 0

Determina si el
argumento es un
caracter ASCII
grafico (hex 0x21
if(isgraph(c)) printf"%c es
4 isgraph -0x7e; octal 041
int ctype.h int isgraph(int c); un caracter imprimible(no
1 (c) -176). Devuelve
espacio)\n",c);
un valor distinto
de cero si es
cierto; en otro
caso devuelve 0

Determina si el
argumento es ua
minuscula.
4 islower Devuelve un if(islower(c)) printf"%c es
int ctype.h int islower(int c);
2 (c) valor distinto de una letra minuscula\n",c);
cero si es cierto;
en otro caso
devuelve 0

Determina si el
argumento es un
digito octal.
4 isodigit Devuelve un if(isodigit(c)) printf"%c es
int ctype.h int isodigit(int c);
3 (c) valor distinto de un digito octal\n",c);
cero si es cierto;
en otro caso
devuelve 0

Determina si el el
argumento es un
caracter ASCII
imprimible (hex
0x20 -0x7e; octal
4 isprint( if(isprint(c)) printf("\n"c
int ctype.h int isprintint c); 040 -176).
4 c) imprimible\n",c);
Devuelve un
valor distinto de
cero si es cierto;
en otro caso
devuelve 0

4 ispunct int ctype.h int ispunct(int c); Determina si el if(ispunct(c)) printf"%c es

5 (c) argumento es un un caracter de
caracter de
 puntuacion.
Devuelve un
valor distinto de
puntuacion\n",c);
cero si es cierto;
en otro caso
devuelve 0

Determina si el
argumento es un
espacio en
4 isspace blanco. Devuelve if(isspace(c)) printf"%c es
int ctype.h int isspace(int c);
6 (c) un valor distinto un espacio\n",c);
de cero si es
cierto; en otro
caso devuelve 0

Determina si el
argumento es
una mayuscula.
4 isupper int isupper(int Devuelve un if(isupper(c)) printf"%c es
int ctype.h
7 (c) c); valor distinto de una mayuscula\n",c);
cero si es cierto;
en otro caso
devuelve 0

Determina si el
argumento es un
digito
hexadecimal.
4 isxdigit( ifisxdigit(c)) print"%c es un
int ctype.h int isxdigit(int c); Devuelve un
8 c) digito hexadecimal\n",c)
valor distinto de
cero si es cierto;
en otro caso
devuelve 0

4 long int Devuelve el calor long lx=-51654,ly;

labs(l) long int math.h
9 labs(long int l); absoluto de 1 ly=labs(lx);

Devuelve el hdouble x,y;

5 double
log(d) double math.h logaritmo natural x=10;
0 log(double d);
de d y=log(x);

Devuelve el hdouble x,y;

5 log10(d double
double math.h logaritmno (en x=10;
1 ) log10(double d);
base 10) de d y=log10(x);

5 malloc( void(pun stdlib.h void Reserva u bytes cadena=malloc(MAX_CHR)

 de memoria.
devuelve un
*malloc(size_t puntero al
2 u) tero) ;
u); principio del
espacio
reservado

double Devuelve d1
5 pow(d1 double x=2.0, y=4.0, z;
double math.h pow(double d1, elevado a la
3 , d2) z=pow(x,y); //z sera 1.60
double d2); potencia d2

Escribe datos en
dispositivo de
salida estandar.
 

Codi
Formato
go

%c Caracter

Entero
%d
Decimal

Real
int printf(const (double
5 printf(.. char o float), print("producto %d y %d
int stdio.h %e
4 .) *formato[,argu notacion es %d\n",x,y,x*y);
mento,...]); cientific
a.

Coma
%f
flotante

Cadena
de
%s
caracter
es

Hexadec
%x imal sin
signo

Escribe un
5 putc(c, int putc(int c,
int stdio.h caracter en el putc('*',demo);
5 f) FILE *f);
archivo f

5 putchar int stdio.h int putchar(int Escribe un putchar('B');

 caracter en el
6 (c) c); dispositivo de
salida estandar 

Escribe una
cadena de
5 int puts(const puts("Desea continuar
puts(s) int stdio.h caracteres en el
7 char *cad) (s/n);
dispositivo de
salida estandar

// visualizar 10 numeros
Devuelve un aleatorios
5
rand( ) int stdlib.h int rand(void); entero positivo
8
aleatorio for (i=0;i<10;i++)
printf("%6d\",rand());
 
Mueve el
5 rewind( void rewind(FILE puntero al
void stdio.h rewind(fx);
9 f) *f); principio del
archivo f

6 scanf(.. int stdio.h int scanf(const Lee datos en scanf('%d %f %c %s, &i,
0 .) char *formato dispositivo de &fp, &c, s);
{,direccion,...]); entrada estandar

Codi
Formato
go

%c Caracter

Enetero
%d
Decimal

Hexadec
%x
imal

Entero
%i
Decimal

Numero
%f
Real

%o Octal

%p Puntero
 %s Cadena

double x, y;
x=0.52;
printf('x =%f
6 double Devuelve el seno
sin(d) double math.h radianes\n",x);
1 sin(double d); de d
y=cos(x);
printf("el coseno de x =
%f\n",y);

6 double Devuelve el seno

sinh(d) double math.h y=sinh(x);
2 sinh(double d); hiperbolico de d

6 double Devuelve la raiz printf("%lf",sqrt(25.0); //se

sqrt(d) double math.h
3 sqrt(double d); cuadrada de d visualiza 5

Inicializa el
void
6 srand(u generador de
void stdlib.h srand(unsigned srand(semilla);
4 ) numeros
u);
aleatorios

Compara dos i=strcmp("MNP",

cadenas de "mnp"); // resultado < 0
caracteres i=strcmp("abc", "abc"); //
lexicograficamen resultado = 0
int strcmp(const
6 strcmp( te. Devuelve un i=strcmp("xy", "abc"); //
int string.h char*s1, const
5 s1, s2) valor negativo si resultado > 0
char *s2);
s1 < s2; 0 si s1 y
s2 son identicas; char s1[80]="Mayo";
y un valor char s2[80]="Octubre";
positivo si s1 > s2 int j;
j=strcmp(s1,s2);
Compara dos
cadenas de
caracteres
lexicograficamen
te, sin diferenciar
int strcmpi(const mayusculas de
6 strcmpi
int string.h char*s1, const minusculas. v=strcmpi(s1,s2);
6 (s1, s2)
char *s2); Devuelve un
valor negativo si
s1 < s2; 0 si s1 y
s2 son identicas;
y un valor
positivo si s1 > s2
 char Copia la cadena char *s1="Pepe Luis";
6 strcpy(s
char string.h *strcpy(char s1, de caracteres s2 char b[12];
7 1, s2)
const char s2); en la cadena s1 strcpy(s2,s1);
cout <<s2<< '\n';

Devuelve el longitud=strlen(nombre);
size_t
6 strlen(s numero de char s[81]="Cadena demo';
int string.h strlen(const char
8 ) caracteres de
*s);
una cadena printf("La longitud de s es:
%d\n" strlen(s));

Pone todos los

caracteres de s a char *cad="----";
6 strset(c char(pun char *strset(char
string.h c (excluyendo el strset (cad,'x'); // cad es
9 , s) tero) *cad, int c);
caracter nulo del ahora xxxx
final \0)

Pasa la orden al
sistema
operativo.
Devuelve cero si
la orden se
7 system( ejecuta
int string.h system(comd); system(dir);
0 s) correctamente;
en otro caso
devuelve un
valor distinto de
cero, tipicamente
-1.

7 double Devuelve la
tan(d) double math.h y=tan(x);
1 tan(double d); tangente de d

Devuelve la
7 double
tanh(d) double math.h tangente a=tanh(x);
2 tanh(double d);
hiperbolica de d

Devuelve el
numero de
segundos
7 time_t
time(p) long int time.h transcurridos time(&hora);
3 time(time_t *h);
despues de un
tiempo base
designado
 Convierte el valor
7
toascii int ctype.h int toascii(int c); del argumento a c=toascii(entero);
4
ASCII

ctype.h
7 tolowe int tolower(int Convierte una c=tolower('s'); //c se
int o
5 r c); letra a minuscula convierte en 's'
stdlib.h

ctype.h
7 touppe int toupper(int Convierte una c=toupper('s');  //c se
int o
6 r c); letra a mayuscula convierte en 'S'
stdlib.h