# |
Nombre de función |
Tipo |
Biblioteca a la cual pertenece |
Sintaxis |
Descripción |
Ejemplo |
1 |
abs(i) |
int |
stdlib.h |
int abs(int i); |
Devuelve el valor absoluto de i |
x = abs(-7) // x es 7 |
2 |
acos(d) |
double |
math.h |
double acos(double d); |
Devuelve el arco coseno de d |
angulo = acos(0.5); // angulo devuelto es phi/3 |
3 |
asin(d) |
double |
math.h |
double asin(double d); |
Devuelve el arco seno de d |
angulo = asin(0.707); // aproximadamente phi/4 |
4 |
atan(d) |
double |
math.h |
double atan(double d);
long double tanl(long double d); |
Devuelve la arco tangente de d. Calcula el arco tangente del argumento
x. Requiere el llamado de la biblioteca complex.h |
angulo atan(1.0); // angulo es phi/4 |
5 |
atan(d1, d2) |
double |
math.h |
double atan(double d1, double d2); |
Devuelve el arco tangente de d1/d2 |
angulo = atan(y, x) |
6 |
atof(s) |
double |
stdlib.h |
double atof(const char *cadena) |
Convierte la cadena s a una cantidad de doble precisión. Requiere
el llamdo de la biblioteca math.h |
double x;
char *cad_dbl = "200.85"; ...
x=atof(cad_dbl); // convierte la cadena "200.85" a valor real |
7 |
atoi(s) |
int |
stdlib.h |
int atoi(const char *cadena) |
Convierte la cadena s a un entero.
La cadena debe tener el siguiente formato:
[espacio en blanco][signo][ddd] (siendo obligatorio los digitos decimales). |
int i;
char *cad_ent="123";
...
i=atoi(cad_ent); //convierte la cadena "123" al entero 123 |
8 |
atol(s) |
long |
stdlib.h |
long atol(const char *cadena); |
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 |
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); |
Reserva memoria para una formación de n elementos , cada uno
de s bytes. Devuelve un puntero al principio del espacio reservado.
Si no existente bastante espacio para el nuevo bloque o bien n o s
es 0, calloc devuelve nulo. |
long *buffer
buffer=(long *) calloc(40, sizeof(long)); |
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 hiperbólico de 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) |
Devuelve la diferencia de tiempo 11(hora2) - 12(hora1) , donde 11 y
12 representan el tiempo transcurrido despues de un tiempo base (ver función
time) |
time_t inicio, fin;
clrscrl();
inicio=time(NULL);
delay(5000)
fin=time(NULL)
print("Diferencia en segundos: %f\n",
difftime(inicio,fin)); |
14 |
exit(u) |
void |
stdlib.h |
void exit(int estado) |
Cierra todos los archivos y buffers y termina el programa. El valor
de u es asignado por la funcion para indicar el estado de terminación. |
exit(0); |
15 |
exp(d) |
double |
math.h |
double exp(double d);
complex exp(complex d) |
Eleve e a la potencia d (e=2,7182818... es la base del
sistema de logaritmos naturales (neperianos)) |
d=100.00;
y=exp(d);
printf("El exponencial de x=%f.\n\n",y); |
16 |
fabs(d) |
double |
math.h |
double fabs(double d); |
Devuelve el valor absoluto de d |
y=fabs(-7.25); // y vale 7.25 |
17 |
fclose(f) |
int |
stdio.h |
int fclose(FILE *f); |
Cierra el archivo f. Devuelve el valor 0 si el archivo se ha cerrado
con exito. |
int fclose(FILE "archivo"); |
18 |
feof(f) |
int |
stdio.h |
int feof(FILE *f); |
Determina si se ha encontrado un fin de archivo. si es asi, devuelve
un valor distinto de cero, en otro caso devuelve 0 |
feof(fichen); |
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(puntero) |
stdio.h |
char *fgets(char s, int s, FILE *f); |
Lee una cadena s, con i caracteres, del archivo f |
fgets(caddemo, 80, fp); |
21 |
floor(d) |
double |
math.h |
double floor(double d); |
Devuelve un valor redondeado por defecto al entero menor mas cercano |
x=floor(6.25); // x vale 6 |
22 |
fmod(d1, d2) |
double |
math.h |
double fmod(double d1, double d2); |
Devuelve el resto de d1/d2 (con el mismo signo que d1) |
resto=fmod(5.0,2.0); // resto igual a 1.0 |
23 |
fopen(s1, s2) |
file(puntero) |
stdio.h |
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 |
"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 |
"rb+" |
Abre un archivo binario para lectura/escritura. |
"wb+" |
Abre un archivo binario para lectura/escritura |
"ab+" |
Abre o crea un archivo binario para lectura/escritura |
|
if ((corriente2=fopen("datos","W+"))==NULL
printf("El archivo...no se ha abierto \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 letra|digito \n",carac);
else
printf("%c no letra|digito \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 <<s2<< '\n'; |
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' |