# 
Function Name 
Type 
Library to which it belongs 
Syntax 
Description 
Example 
1 
abs(i) 
int 
stdlib.h 
int abs(int i); 
Returns the absolute value of i 
x = abs(7) // x es 7 
2 
acos(d) 
double 
math.h 
double acos(double d); 
Returns the arc cosine of d 
angle = acos (0.5) / / returned is phi angle / 3 
3 
asin(d) 
double 
math.h 
double asin(double d); 
Returns the arc sine of d 
angle = asin (0.707) / / about phi / 4 
4 
atan(d) 
double 
math.h 
double atan(double d);
long double tanl(long double d); 
Returns the arc tangent of d. Calculates the arc tangent of x. Requires library called complex.h 
angle atan (1.0) / / angle is phi / 4 
5 
atan(d1, d2) 
double 
math.h 
double atan(double d1, double d2); 
Returns the arc tangent of d1/d2 
angle = atan (y, x) 
6 
atof(s) 
double 
stdlib.h 
double atof(const char *cadena) 
Convert string s to a double precision number. Requires llamda math.h library 
double x,
char * cad_dbl = "200.85" ...
x = atof (cad_dbl) / / convert the string "200.85" a real value 
7 
atoi(s) 
int 
stdlib.h 
int atoi(const char *cadena) 
Convert string s to an integer.
The string must have the following format:
[blank] [sign] [ddd] (still mandatory decimal digits). 
nt i,
char * cad_ent = "123"
...
i = atoi (cad_ent) / / converts the string "123" to integer 123 
8 
atol(s) 
long 
stdlib.h 
long atol(const char *cadena); 
Convert string s to a long integer.
The string must have the following format:
[blank] [sign] [ddd] (still mandatory decimal digits). 
long int i;
char cad_ent = "9876543",
...
i = atol (cad_ent) / / convert the string "9876543" to long integer 
9 
calloc(n, s) 
void(puntero) 
malloc.h y stdlib.h
o bien
alloc.h y
stdlib.h 
void *calloc(size_t n, size_t s); 
Allocate memory for a formation of n elements, each of s bytes. Returns a pointer to the beginning of the reserved space.
If enough space exists for the new block or we is 0, calloc returns null. 
long * buffer
buffer = (long *) calloc (40, sizeof (long)); 
10 
ceil(d) 
double 
math.h 
double ceil(double d); 
Returns a value rounded up to the next higher integer 
rounding = ceil (5.1) / / rounding is 6 
11 
cos(d) 
double 
math.h 
double cos(double d);
complex cos(complex d); 
Returns the cosine of d 
coseno_x = cos (1.6543) 
12 
cosh(d) 
double 
math.h 
double cos(double d);
complex cos(complex d); 
Returns the hyperbolic cosine of d 
d = 1.00;
printf ("d =% f \ n \ n, d); 
13 
difftime(11, 12) 
double 
time.h 
double difftime(time_t hora2, time_t hora1) 
Returns the time difference 11 (TIME2)  12 (hour1), where 11 and 12
represent the time elapsed after a time base (see function time) 
time_t start, end;
clrscrl ();
start = time (NULL);
delay (5000)
end = time (NULL)
print ("Difference in seconds:% f \ n",
difftime (start, end)); 
14 
exit(u) 
void 
stdlib.h 
void exit(int estado) 
Close all files and buffers and the program ends. The value of u is assigned by the function to indicate the completion status. 
exit(0); 
15 
exp(d) 
double 
math.h 
double exp(double d);
complex exp(complex d) 
Raise e to the power d ( e = 2.7182818 ... is the base of natural logarithms system (neperian)) 
d = 100.00,
y = exp (d)
printf ("The exponential x =% f. \ n \ n", y); 
16 
fabs(d) 
double 
math.h 
double fabs(double d); 
Returns the absolute value of d 
y = fabs (7.25) / / and is worth 7.25 
17 
fclose(f) 
int 
stdio.h 
int fclose(FILE *f); 
Close the file f. Returns 0 if the file was closed successfully. 
int fclose (FILE "file"); 
18 
feof(f) 
int 
stdio.h 
int feof(FILE *f); 
Determines whether an end of file found. if so, returns a nonzero value, otherwise returns 0 
feof (chips); 
19 
fgetc(f) 
int 
stdio.h 
int fgetc(FILE f); 
Read character from file f 
c + fgetc (fp) 
20 
fegts(s, i, f) 
char(puntero) 
stdio.h 
char *fgets(char s, int s, FILE *f); 
Reads a string s with characters i, f File 
fgets (caddemo, 80, fp); 
21 
floor(d) 
double 
math.h 
double floor(double d); 
Returns a value rounded down to nearest integer less 
x = floor (6.25) / / x is 6 
22 
fmod(d1, d2) 
double 
math.h 
double fmod(double d1, double d2); 
Returns the remainder of d1/d2 (with the same sign as d1) 
rest = fmod (5.0,2.0) / / rest equal to 1.0 
23 
fopen(s1, s2) 
file(puntero) 
stdio.h 
FILE *fopen(const char *s1, const char *s2) 
Opens a file named s1, s2 type. Returns a pointer to the file.
*
Way 
Action 
"R" 
Open for reading 
"W" 
Opens an empty file for writing 
"A" 
Opens for writing at end of file 
"R+" 
Open for reading / writing 
"W+" 
Opens an empty file for read / write 
"A+" 
Open for reading and add 
"Rb" 
Open a binary file for reading. 
"Wb" 
Open a binary file for writing 
"Ab" 
Open a binary file to add 
"Rb+" 
Open a binary file for read / write. 
"Wb+" 
Open a binary file for read / write 
"Ab+" 
Open or create binary file for read / write 

if ((corriente2 = fopen ("data", "W +"))== NULL
printf ("File not opened ... \ n"); 
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); 
27 
fread(s, i1, i2, f) 
int 
stdio.h 
size_t fread(void *b, size_t t, size_t n, FILE *f); 
Lee i2 elementos, cada uno de tamano i1 bytes, desde el archivo f hasta
la cadena s 
fread(buf, strlen(msg)+1, 1, flujo); 
28 
free(p) 
void 
malloc.h o stdlib.h 
void free(void *dir_memoria); 
Libera un bloque de memoria reservada cuyo principio esta indicado
por p. 
char *cad;
// asignar memoria a la cadena
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); 
30 
fseek(f, l, i) 
int 
stdio.h 
int fseek(FILE *f, long desplaza, int origen); 
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
Origen 
Significado 
SEEK_SET 
Principio de archivo 
SEEK_CUR 
Posicion actual puntero 
SEEK_END 
Final del archivo 

fseek(f1,OL,SEEK_SET); // ir al principio 
31 
ftell(f) 
long int 
stdio.h 
long int ftell(FILE *f); 
Devuelve la posicion actual del puntero dentro del archivo f 
ftell(fichen) 
32 
fwrite(s, i1, i2, f) 
int 
stdio.h 
size_t fwrite(const void *p, size_t i1, size_t i2, FILE *f); 
Escribe i2 elementos, cada uno de tamano 1 bytes, desde la cadena s
hasta el archivo f 
num=fwrite(lista,sizeof(char),25,flujo); 
33 
getc(f) 
int 
stdio.h 
int getc(FILE *f); 
Lee un caracter del archivo f 
while(c=getc(fx) !=EOF {
print ("%c",c);
} 
34 
getchar( ) 
int 
stdio.h 
int getchar(void); 
Lee un caracter desde el dispostivo de entrada estandar 
int c;
while((*c=getchar()) != '\n')
print ("%c",c); 
35 
gets(s) 
char(puntero) 
stdio.h 
char *gets(char *cad); 
Lee una cadena de caracteres desde el dispositivo de entrada estandar 
gets(nombre); 
36 
isalnum(c) 
int 
ctype.h 
int isalnum(int c); 
Determina si el argumento es alfanumerico. Devuelve un valor disitinto
de cero si es cierto; en otro caso devuelve 0 
carac=getch();
if (isalnum(carac))
print("%c letradigito \n",carac);
else
printf("%c no letradigito \n", carac); 
37 
isalpha(c) 
int 
ctype.h 
int isalpha(int c); 
Determina si el argumento es alfabetico. Devuelve un valor distinto
de cero si es cierto; en otro caso devuelve 0. 
int c;
if (isalpha(c)) printf("%c es letra\n",c); 
38 
isascii(c) 
int 
ctype.h 
int isascii(int c); 
Determina si el argumento es un caracter ASCII. Devuelve un valor disitinto
de cero si es cierto; en otro caso devuelve 0 
int c;
if (isascii(c)) printf('%c es un ascii\n",c) 
39 
iscntrl(c) 
int 
ctype.h 
int isacntrl(int c); 
Determina si el argumento es un caracter ASCII de control. Devuelve
un valor distinto de cero si es cierto; en otro caso devuelve 0 
if(iscntrl(c)) printf"%c es un caracter de control\n",c); 
40 
isdigit(c) 
int 
ctype.h 
int isdigit(int c); 
Determina si el numero es un digito decimal. Devuelve un valor disitinto
de cero si es cierto; en otro caso devuelve 0 
if(isdigit(c)) printf"%c es un digito\n",c); 
41 
isgraph(c) 
int 
ctype.h 
int isgraph(int c); 
Determina si el argumento es un caracter ASCII grafico (hex 0x21 0x7e;
octal 041 176). Devuelve un valor distinto de cero si es cierto; en otro
caso devuelve 0 
if(isgraph(c)) printf"%c es un caracter imprimible(no espacio)\n",c); 
42 
islower(c) 
int 
ctype.h 
int islower(int c); 
Determina si el argumento es ua minuscula. Devuelve un valor distinto
de cero si es cierto; en otro caso devuelve 0 
if(islower(c)) printf"%c es una letra minuscula\n",c); 
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 cierto; en otro caso devuelve 0 
if(isodigit(c)) printf"%c es un digito octal\n",c); 
44 
isprint(c) 
int 
ctype.h 
int isprintint c); 
Determina si el el argumento 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 
if(isprint(c)) printf("\n"c imprimible\n",c); 
45 
ispunct(c) 
int 
ctype.h 
int ispunct(int c); 
Determina si el argumento es un caracter de puntuacion. Devuelve un
valor distinto de cero si es cierto; en otro caso devuelve 0 
if(ispunct(c)) printf"%c es un caracter de puntuacion\n",c); 
46 
isspace(c) 
int 
ctype.h 
int isspace(int c); 
Determina si el argumento es un espacio en blanco. Devuelve un valor
distinto de cero si es cierto; en otro caso devuelve 0 
if(isspace(c)) printf"%c es un espacio\n",c); 
47 
isupper(c) 
int 
ctype.h 
int isupper(int c); 
Determina si el argumento es una mayuscula. Devuelve un valor distinto
de cero si es cierto; en otro caso devuelve 0 
if(isupper(c)) printf"%c es una mayuscula\n",c); 
48 
isxdigit(c) 
int 
ctype.h 
int isxdigit(int c); 
Determina si el argumento es un digito hexadecimal. Devuelve un valor
distinto de cero si es cierto; en otro caso devuelve 0 
ifisxdigit(c)) print"%c es un digito hexadecimal\n",c) 
49 
labs(l) 
long int 
math.h 
long int labs(long int l); 
Devuelve el calor absoluto de 1 
long lx=51654,ly;
ly=labs(lx); 
50 
log(d) 
double 
math.h 
double log(double d); 
Devuelve el logaritmo natural de d 
hdouble x,y;
x=10;
y=log(x); 
51 
log10(d) 
double 
math.h 
double log10(double d); 
Devuelve el logaritmno (en base 10) de d 
hdouble x,y;
x=10;
y=log10(x); 
52 
malloc(u) 
void(puntero) 
stdlib.h 
void *malloc(size_t u); 
Reserva u bytes de memoria. devuelve un puntero al principio del espacio
reservado 
cadena=malloc(MAX_CHR); 
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 
54 
printf(...) 
int 
stdio.h 
int printf(const char *formato[,argumento,...]); 
Escribe datos en dispositivo de salida estandar.
Codigo 
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 
putc('*',demo); 
56 
putchar(c) 
int 
stdio.h 
int putchar(int c); 
Escribe un caracter en el dispositivo de salida estandar 
putchar('B'); 
57 
puts(s) 
int 
stdio.h 
int puts(const char *cad) 
Escribe una cadena de caracteres en el dispositivo de salida estandar 
puts("Desea continuar (s/n); 
58 
rand( ) 
int 
stdlib.h 
int rand(void); 
Devuelve un entero positivo aleatorio 
// visualizar 10 numeros aleatorios
for (i=0;i<10;i++)
printf("%6d\",rand());

59 
rewind(f) 
void 
stdio.h 
void rewind(FILE *f); 
Mueve el puntero al principio del archivo f 
rewind(fx); 
60 
scanf(...) 
int 
stdio.h 
int scanf(const char *formato {,direccion,...]); 
Lee datos en dispositivo de entrada estandar
Codigo 
Formato 
%c 
Caracter 
%d 
Enetero Decimal 
%x 
Hexadecimal 
%i 
Entero Decimal 
%f 
Numero Real 
%o 
Octal 
%p 
Puntero 
%s 
Cadena 

scanf('%d %f %c %s, &i, &fp, &c, s); 
61 
sin(d) 
double 
math.h 
double sin(double d); 
Devuelve el seno de d 
double x, y;
x=0.52;
printf('x =%f radianes\n",x);
y=cos(x);
printf("el coseno de x =%f\n",y); 
62 
sinh(d) 
double 
math.h 
double sinh(double d); 
Devuelve el seno hiperbolico de d 
y=sinh(x); 
63 
sqrt(d) 
double 
math.h 
double sqrt(double d); 
Devuelve la raiz cuadrada de d 
printf("%lf",sqrt(25.0); //se visualiza 5 
64 
srand(u) 
void 
stdlib.h 
void srand(unsigned u); 
Inicializa el generador de numeros aleatorios 
srand(semilla); 
65 
strcmp(s1, s2) 
int 
string.h 
int strcmp(const char*s1, const char *s2); 
Compara dos cadenas de caracteres lexicograficamente. Devuelve un valor
negativo si s1 < s2; 0 si s1 y s2 son identicas; y un valor positivo
si s1 > s2 
i=strcmp("MNP", "mnp"); // resultado < 0
i=strcmp("abc", "abc"); // resultado = 0
i=strcmp("xy", "abc"); // resultado > 0
char s1[80]="Mayo";
char s2[80]="Octubre";
int j;
j=strcmp(s1,s2); 
66 
strcmpi(s1, s2) 
int 
string.h 
int strcmpi(const char*s1, const char *s2); 
Compara dos cadenas de 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 
v=strcmpi(s1,s2); 
67 
strcpy(s1, s2) 
char 
string.h 
char *strcpy(char s1, const char s2); 
Copia la cadena de caracteres s2 en la cadena s1 
char *s1="Pepe Luis";
char b[12];
strcpy(s2,s1);
cout <

68 
strlen(s) 
int 
string.h 
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)); 
69 
strset(c, s) 
char(puntero) 
string.h 
char *strset(char *cad, int c); 
Pone todos los caracteres de s a c (excluyendo el caracter nulo del
final \0) 
char *cad="";
strset (cad,'x'); // cad es ahora xxxx 
70 
system(s) 
int 
string.h 
system(comd); 
Pasa la orden al sistema operativo. Devuelve cero si la orden se ejecuta
correctamente; en otro caso devuelve un valor distinto de cero, tipicamente
1. 
system(dir); 
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); 
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 
time(&hora); 
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' 