Los operadores aritmticos nos permiten, bsicamente, hacer cualquier operacin aritmtica, que necesitemos (ejemplo: suma, resta,

multiplicacin, etc).
En la siguiente tabla se muestran los operadores de los que disponemos en C y su funcin asociada.

Los operadores relacionales son smbolos que se usan para comparar dos valores. Si el resultado de la comparacin es correcto la expresin considerada
es verdadera, en caso contrario es falsa. Por ejemplo, 8>4 (ocho mayor que cuatro) es verdadera, se representa por el valor true del tipo bsico bolean, en
cambio, 8<4 (ocho menor que cuatro) es falsa, false. En la primera columna de la tabla, se dan los smbolos de los operadores relacionales, en la segunda, el
nombre de dichos operadores, y a continuacin su significado mediante un ejemplo.

Como operadores lgicos designamos a aquellos operadores que nos permiten ``conectar'' un par de propiedades (al igual que en lgica):
Numero = 2701;
if ( EsPrimo(numero) && (numero > 1000) ){
/* Ejecutaremos este cdigo si numero */
/* es primo y nmero es mayor que 100 */
Los operadores lgicos de los que disponemos en C son los siguientes:

Al igual que con la igualdad hay que tener especial cuidado con los operadores && y , ya que si ponemos solamente un & o un , nos estamos refiriendo a
un ``and'' o un ``or'' a nivel de bit, por lo que el cdigo puede que no haga lo que queremos (o que algunas veces lo haga y otras veces no).
LIBRERIAS EN LENGUAJE C
Otras librerias que no tienen funciones asociadas. Pero tienen macros constantes y/o estructuras.

#include <assert.h>

#include <errno.h>

#include <float.h>

#include <limits.h>

#include <stdarg.h>

#include <stddef.h>

RESUMEN DE LIBRERIAS
assert.h Contiene una macro para el diagnstico dentro de los programas.
ctype.h Contiene varias funciones para comprobacin de tipos y transformacin de caracteres.
errno.h Contiene varias macros usadas para informar de errores.
limits.h Contienen varias macros que definen constantes para el tamao de tipo enteros.
float.h Contienen varias macros que definen constantes para el tamao de tipo flotante.
locale.h Contienen varias macros, funciones y tipos para unidades locales, como unidad monetaria, tiempo, dgitos, etc.
math.h Contiene una macro y varias funciones matemticas.
setjmp.h Contienen declaraciones que proporcionan una forma de evitar la secuencia normal de llamada y regreso de funciones.
signal.h Contiene un tipo, dos funciones y varias macros para manejar condiciones excepcionales que aparecen durante la ejecucin, tal como una seal
de interrupcin de una fuente externa o un error en la ejecucin.
stdarg.h Contiene un tipo y tres macros que proporcionan recursos para recorrer una lista de argumentos de funcin de tamao y tipo desconocido.
stddef.h Contiene varios tipos y macros que tambin estn definidas en otras libreras, como size_t.
stdio.h Contiene tipos, macros y funciones para la realizacin de tareas de E/S.
stdlib.h Contiene tipos, macros y funciones para la conversin numrica, generacin de nmeros aleatorios, bsquedas y ordenacin, gestin de
memoria y tareas similares.
string.h Contiene tipos, macros y funciones para la manipulacin de cadenas de caracteres.
time.h Contiene tipos, macros y funciones para la la manipulacin de informacin sobre fechas y horas.

Tipos datos: char, int, float, long, long long, short, double, void.

CADENAS DE FORMATO

d, i

entero decimal con signo

entero octal sin signo

entero decimal sin signo

entero hexadecimal sin signo (en minsculas)

entero hexadecimal sin signo (en maysculas)

Coma flotante en la forma [-]dddd.dddd

Coma flotante en la forma [-]d.dddd e[+/-]ddd

Coma flotante segn el valor

Como e pero en maysculas

Como g pero en maysculas

un carcter

cadena de caracteres terminada en '\0'

imprime el carcter %

puntero

SECUENCIA DE ESCAPE
\a

Alerta

\b

Espacio atrs

\f

Salto de pgina

\n

Salto de lnea

\r

Retorno de carro

\t

Tabulacin horizontal

\v

Tabulacin vertical

\\

Barra invertida

\'

Comilla simple

\"

Comillas dobles

\OOO

Visualiza un carcter cuyo cdigo ASCII es OOO en octal

\xHHH

Visualiza un carcter cuyo cdigo ASCII es HHH en hexadecimal

Funcionabilidad de la Funcin System, que pertenece a la librera <stlib.h>

Colores de Fondo
0
1
2
3
4
5
6
7
8
9

=
=
=
=
=
=
=
=
=
=

Negro
Azul
Verde
Aguamarina
Rojo
Prpura
Amarillo
Blanco
Gris
Azul claro

Colores de Fuente
a = Verde claro
b = Aguamarina claro
c = Rojo claro
d = Prpura claro
e = Amarillo claro
f = Blanco brillante
Por Prof.Luis Eduardo Aponte - Publicado en: Basica

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 ingls y es lo que se llama cabecera.
Para incluir alguna funcin perteneciente a estas cabeceras debemos escribir lneas de cdigo 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 Biblioteca Descripcion
assert.h

Es proporcionar una definicion de la macro assert, que imprime un mensaje de error y aborta el programa

alloc.h

Existen funciones para asignar, liberar memoria, u obtener informacion de bloques de memoria.

ctype.h

Son funciones que nos permiten conocer la naturaleza de un caracter, o bien para convertir de mayusculas a minusculas y
viceversa; y valores enteros a codigos ASCII.

dir.h

Esto permite ordenar, crear, modificar, mover y eliminar directorios

errno.h

Representa los numeros de error, despues que ocurre un error se 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

math.h

Contiene las funciones matematicas estandar utilizadas en C y C++

setjmp.h

Define el tipo de jmp_buf para algunas funciones.

signal.h

Contiene funciones de estado.

stdarg.h

Define funciones que pueden ser llamadas con diferentes numeros de argumentos, de modo que se pueda escribir f(a) y
f(a,b).

stdef.h

Se definen algunos tipos especiales

stdio.h

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

stlib.h

Declara funciones que son utiles para diferentes propositos, en especial de busqueda y ordenacion.

string.h

Este archivo contiene funciones para manejo de cadenas de caracteres.

time.h

Contiene funciones relativas a fechas y horas

Funciones Encontradas en las Bibliotecas

Nombre de
funcin

Tipo

Biblioteca
a la cual Sintaxis
pertenece

Descripcin

abs(i)

int

stdlib.h

int abs(int i);

Devuelve el valor absoluto de

x = abs(-7) // x es 7
i

acos(d)

double

math.h

double acos(double d);

Devuelve el arco coseno de d angulo = acos(0.5); // angulo devuelto es phi/3

asin(d)

double

math.h

double asin(double d);

Devuelve el arco seno de d

Devuelve la arco tangente de

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

Ejemplo

angulo = asin(0.707); // aproximadamente phi/4

atan(d)

double

math.h

double atan(double d);

long double tanl(long
double d);

atan(d1, d2)

double

math.h

double atan(double d1,

double d2);

Devuelve el arco tangente de

angulo = atan(y, x)
d1/d2

double atof(const char

*cadena)

Convierte la cadena s a una

cantidad de doble precisin.
Requiere el llamdo de la
biblioteca math.h

atof(s)

double

stdlib.h

atoi(s)

int

stdlib.h

int atoi(const char *cadena) Convierte la cadena s a un

entero.
La cadena debe tener el

double x;
char *cad_dbl = "200.85"; ...
x=atof(cad_dbl); // convierte la cadena
"200.85" a valor real
int i;
char *cad_ent="123";
...

stdlib.h

long atol(const char

*cadena);

siguiente formato:
[espacio en blanco][signo]
[ddd] (siendo obligatorio los
digitos decimales).

i=atoi(cad_ent); //convierte la cadena "123" al

entero 123

Convierte la cadena s a un
entero largo.
La cadena debe tener el
siguiente formato:
[espacio en blanco][signo]
[ddd] (siendo obligatorio los
digitos decimales).

long int i;
char cad_ent="9876543";
...
i=atol(cad_ent); //convierte la cadena
"9876543" al entero largo

atol(s)

long

calloc(n, s)

Reserva memoria para una

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

10

ceil(d)

double

math.h

double ceil(double d);

Devuelve un valor
redondeado por exceso al
siguiente entero mayor

redondeo=ceil(5.1); //redondeo es 6

11

cos(d)

double

math.h

double cos(double d);

complex cos(complex d);

Devuelve el coseno de d

coseno_x=cos(1.6543)

12

cosh(d)

double

math.h

double cos(double d);

complex cos(complex d);

Devuelve el coseno
hiperblico de d

d=1.00;
printf("d=%f.\n\n,d);

Devuelve la diferencia de
tiempo 11(hora2) 12(hora1) , donde 11 y 12
representan el tiempo
transcurrido despues de un
tiempo base (ver funcin
time)

time_t inicio, fin;

clrscrl();
inicio=time(NULL);
delay(5000)
fin=time(NULL)
print("Diferencia en segundos: %f\n",
difftime(inicio,fin));

Cierra todos los archivos y

buffers y termina el
programa. El valor de u es
asignado por la funcion para
indicar el estado de

exit(0);

13

difftime(11, 12) double

time.h

double difftime(time_t
hora2, time_t hora1)

14

exit(u)

stdlib.h

void exit(int estado)

void

terminacin.
15

exp(d)

double

math.h

double exp(double d);

complex exp(complex d)

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

16

fabs(d)

double

math.h

double fabs(double d);

Devuelve el valor absoluto de

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

int fclose(FILE *f);

Cierra el archivo f. Devuelve

el valor 0 si el archivo se ha int fclose(FILE "archivo");
cerrado con exito.

17

fclose(f)

int

stdio.h

18

feof(f)

int

stdio.h

int feof(FILE *f);

Determina si se ha encontrado
un fin de archivo. si es asi,
feof(fichen);
devuelve un valor distinto de
cero, en otro caso devuelve 0

19

fgetc(f)

int

stdio.h

int fgetc(FILE f);

Lee un caracter del archivo f c+fgetc(fp)

20

fegts(s, i, f)

char(punte
stdio.h
ro)

char *fgets(char s, int s,

FILE *f);

Lee una cadena s, con i

caracteres, del archivo f

fgets(caddemo, 80, fp);

x=floor(6.25); // x vale 6

21

floor(d)

double

math.h

double floor(double d);

Devuelve un valor
redondeado por defecto al
entero menor mas cercano

22

fmod(d1, d2)

double

math.h

double fmod(double d1,

double d2);

Devuelve el resto de d1/d2

resto=fmod(5.0,2.0); // resto igual a 1.0
(con el mismo signo que d1)

23

fopen(s1, s2)

file(punter stdio.h
o)

FILE *fopen(const char

*s1, const char *s2)

Abre un archivo llamado s1,

del tipo s2. Devuelve un
puntero al archivo. *
Modo Accion
"r"

Abre para lectura

"w"

Abre un archivo
vacio para
escritura

"a"

Abre para
escritura al final
del archivo

"r+"

Abre para
lectura/escritura

if ((corriente2=fopen("datos","W+"))==NULL
printf("El archivo...no se ha abierto \n");

"w+"

Abre un archivo
vacio para
lectura/escritura

"a+"

Abre para lectura

y anadir

"rb"

Abre un archivo
binario para
lectura.

"wb"

Abre un archivo
binario para
escritura

"ab"

Abre un archivo
binario para
anadir

Abre un archivo
"rb+" binario para
lectura/escritura.
Abre un archivo
"wb+" binario para
lectura/escritura
Abre o crea un
archivo binario
"ab+"
para
lectura/escritura
24

fprintf(f, ...)

int

stdio.h

int fprintf(FILE *f, const

char *formato [,arg,...]);

Escribe datos en el archivo f

(el resto de los argumentos

fprintf(f1, "El resultado es %f\n",result);

25

fputc(c, f)

int

stdio.h

int fputc(int c, FILE *f);

Escribe un caracter en el
archivo f

fputc(*(p++), stdout);

26

fputs(s, f)

int

stdio.h

int fputs(const char *cad,

FILE *f)

Escribe una cadena de

caracteres en el archivo f

fputs("esto es una prueba", f1);

Lee i2 elementos, cada uno de

size_t fread(void *b, size_t
tamano i1 bytes, desde el
fread(buf, strlen(msg)+1, 1, flujo);
t, size_t n, FILE *f);
archivo f hasta la cadena s

27

fread(s, i1, i2, f) int

stdio.h

28

free(p)

malloc.h o void free(void

stdlib.h
*dir_memoria);

void

Libera un bloque de memoria char *cad;

reservada cuyo principio esta // asignar memoria a la cadena
indicado por p.
cad=(char *)malloc(50);
...

free(cad); // liberar memoria

29

fscanf(f, ...)

int

math.h

int fscanf(FILE *f, const

char *formato, [,
direccion,... ]);

Lee datos del archivo f ( el

resto de los argumentos

fscanf(flujo, %s%f, cad, &f);

Mueve el puntero al 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
30

fseek(f, l, i)

int

stdio.h

int fseek(FILE *f, long

desplaza, int origen);

Origen

Significado

SEEK_SET

Principio de
archivo

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

Posicion
SEEK_CUR actual
puntero
SEEK_END
31

ftell(f)

long int

32

fwrite(s, i1, i2,

int
f)

Final del
archivo

Devuelve la posicion actual

del puntero dentro del archivo ftell(fichen)
f

stdio.h

long int ftell(FILE *f);

stdio.h

size_t fwrite(const void *p, Escribe i2 elementos, cada

size_t i1, size_t i2, FILE
uno de tamano 1 bytes, desde num=fwrite(lista,sizeof(char),25,flujo);
*f);
la cadena s hasta el archivo f

33

getc(f)

int

stdio.h

int getc(FILE *f);

while(c=getc(fx) !=EOF {
Lee un caracter del archivo f
print ("%c",c);
}

34

getchar( )

int

stdio.h

int getchar(void);

Lee un caracter desde el

dispostivo de entrada
estandar

35

gets(s)

char(punte
stdio.h
ro)

char *gets(char *cad);

Lee una cadena de caracteres

desde el dispositivo de
gets(nombre);
entrada estandar

36

isalnum(c)

int

int isalnum(int c);

ctype.h

int c;
while((*c=getchar()) != '\n')
print ("%c",c);

Determina si el argumento es carac=getch();

alfanumerico. Devuelve un
if (isalnum(carac))

valor disitinto de cero si es

print("%c letra|digito \n",carac);
cierto; en otro caso devuelve else
0
printf("%c no letra|digito \n", carac);
37

38

39

40

41

42

isalpha(c)

isascii(c)

iscntrl(c)

isdigit(c)

isgraph(c)

islower(c)

int

int

int

int

int

int

ctype.h

ctype.h

ctype.h

ctype.h

ctype.h

ctype.h

int isalpha(int c);

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

int isascii(int c);

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

int isacntrl(int c);

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

int isdigit(int c);

Determina si el numero es un
digito decimal. Devuelve un
valor disitinto de cero si es
if(isdigit(c)) printf"%c es un digito\n",c);
cierto; en otro caso devuelve
0

int isgraph(int c);

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

int islower(int c);

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

43

isodigit(c)

int

ctype.h

int isodigit(int c);

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

44

isprint(c)

int

ctype.h

int isprintint c);

Determina si el el argumento if(isprint(c)) printf("\n"c imprimible\n",c);

es un caracter ASCII
imprimible (hex 0x20 -0x7e;
octal 040 -176). Devuelve un
valor distinto de cero si es
cierto; en otro caso devuelve
0

45

46

47

ispunct(c)

isspace(c)

isupper(c)

int

int

int

ctype.h

ctype.h

ctype.h

int ispunct(int c);

Determina si el argumento es
un caracter de puntuacion.
if(ispunct(c)) printf"%c es un caracter de
Devuelve un valor distinto de
puntuacion\n",c);
cero si es cierto; en otro caso
devuelve 0

int isspace(int c);

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

int isupper(int c);

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

48

isxdigit(c)

int

ctype.h

int isxdigit(int c);

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

49

labs(l)

long int

math.h

long int labs(long int l);

Devuelve el calor absoluto de long lx=-51654,ly;

1
ly=labs(lx);

50

log(d)

double

math.h

double log(double d);

hdouble x,y;
Devuelve el logaritmo natural
x=10;
de d
y=log(x);

double log10(double d);

Devuelve el logaritmno (en

base 10) de d

void *malloc(size_t u);

Reserva u bytes de memoria.

devuelve un puntero al
cadena=malloc(MAX_CHR);
principio del espacio
reservado

51

52

log10(d)

double

math.h

malloc(u)

void(punte
stdlib.h
ro)

hdouble x,y;
x=10;
y=log10(x);

53

pow(d1, d2)

double

math.h

double pow(double d1,

double d2);

Devuelve d1 elevado a la
potencia d2

double x=2.0, y=4.0, z;

z=pow(x,y); //z sera 1.60

Escribe datos en dispositivo

de salida estandar.
Codigo

54

printf(...)

int

stdio.h

int printf(const char

*formato[,argumento,...]);

Formato

%c

Caracter

%d

Entero
Decimal

%e

Real (double o
float), notacion
cientifica.

%f

Coma flotante

%s

Cadena de
caracteres

%x

Hexadecimal
sin signo

print("producto %d y %d es %d\n",x,y,x*y);

55

putc(c, f)

int

stdio.h

int putc(int c, FILE *f);

Escribe un caracter en el
archivo f

56

putchar(c)

int

stdio.h

int putchar(int c);

Escribe un caracter en el
putchar('B');
dispositivo de salida estandar

int puts(const char *cad)

Escribe una cadena de

caracteres en el dispositivo de puts("Desea continuar (s/n);
salida estandar

57

puts(s)

int

stdio.h

putc('*',demo);

// visualizar 10 numeros aleatorios

58

rand( )

int

stdlib.h

int rand(void);

Devuelve un entero positivo

aleatorio

59

rewind(f)

void

stdio.h

void rewind(FILE *f);

Mueve el puntero al principio

rewind(fx);
del archivo f

60

scanf(...)

int

stdio.h

int scanf(const char

*formato {,direccion,...]);

Lee datos en dispositivo de

entrada estandar
Codigo Formato

for (i=0;i<10;i++)
printf("%6d\",rand());

scanf('%d %f %c %s, &i, &fp, &c, s);

%c

Caracter

%d

Enetero
Decimal

%x

Hexadecimal

%i

Entero
Decimal

%f

Numero Real

%o

Octal

%p

Puntero

%s

Cadena
double x, y;
x=0.52;
printf('x =%f radianes\n",x);
y=cos(x);
printf("el coseno de x =%f\n",y);

61

sin(d)

double

math.h

double sin(double d);

Devuelve el seno de d

62

sinh(d)

double

math.h

double sinh(double d);

Devuelve el seno hiperbolico

y=sinh(x);
de d

63

sqrt(d)

double

math.h

double sqrt(double d);

Devuelve la raiz cuadrada de

printf("%lf",sqrt(25.0); //se visualiza 5
d

64

srand(u)

void

stdlib.h

void srand(unsigned u);

Inicializa el generador de
numeros aleatorios

srand(semilla);
i=strcmp("MNP", "mnp"); // resultado < 0
i=strcmp("abc", "abc"); // resultado = 0
i=strcmp("xy", "abc"); // resultado > 0

65

strcmp(s1, s2)

int

string.h

66

strcmpi(s1, s2) int

string.h

int strcmp(const char*s1,

const char *s2);

int strcmpi(const char*s1,

const char *s2);

Compara dos cadenas de

caracteres lexicograficamente.
Devuelve un valor negativo si
char s1[80]="Mayo";
s1 < s2; 0 si s1 y s2 son
char s2[80]="Octubre";
identicas; y un valor positivo
int j;
si s1 > s2
j=strcmp(s1,s2);
Compara dos cadenas de
v=strcmpi(s1,s2);
caracteres lexicograficamente,
sin diferenciar mayusculas de
minusculas. Devuelve un
valor negativo si s1 < s2; 0 si
s1 y s2 son identicas; y un

valor positivo si s1 > s2

67

strcpy(s1, s2)

char

string.h

68

strlen(s)

int

string.h

strset(c, s)

char(punte
string.h
ro)

69

char *s1="Pepe Luis";

char *strcpy(char s1, const Copia la cadena de caracteres
char b[12];
char s2);
s2 en la cadena s1
strcpy(s2,s1);
cout <<s2<< '\n';
size_t strlen(const char *s);

Devuelve el numero de
caracteres de una cadena

longitud=strlen(nombre);
char s[81]="Cadena demo';
printf("La longitud de s es: %d\n" strlen(s));

char *strset(char *cad, int

c);

Pone todos los caracteres de s

char *cad="----";
a c (excluyendo el caracter
strset (cad,'x'); // cad es ahora xxxx
nulo del final \0)

70

system(s)

int

string.h

system(comd);

Pasa la orden al sistema

operativo. Devuelve cero si la
orden se ejecuta
system(dir);
correctamente; en otro caso
devuelve un valor distinto de
cero, tipicamente -1.

71

tan(d)

double

math.h

double tan(double d);

Devuelve la tangente de d

y=tan(x);

72

tanh(d)

double

math.h

double tanh(double d);

Devuelve la tangente
hiperbolica de d

a=tanh(x);

time(&hora);

73

time(p)

long int

time.h

time_t time(time_t *h);

Devuelve el numero de
segundos transcurridos
despues de un tiempo base
designado

74

toascii

int

ctype.h

int toascii(int c);

Convierte el valor del

argumento a ASCII

c=toascii(entero);

75

tolower

int

ctype.h o
stdlib.h

int tolower(int c);

Convierte una letra a

minuscula

c=tolower('s'); //c se convierte en 's'

76

toupper

int

ctype.h o
stdlib.h

int toupper(int c);

Convierte una letra a

mayuscula

c=toupper('s'); //c se convierte en 'S'