Está en la página 1de 14

Biblioteca

Nombre de Tipo de
a la cual Sintaxis Descripción Ejemplo
función retorno
pertenece

carac=getch();
Determina si el argumento es
if (isalnum(carac))
alfanumérico. Devuelve un valor
isalnum(c) int ctype.h int isalnum(char c); printf("%c letra|digito \n",carac);
distinto de cero si es cierto; en otro
else
caso devuelve 0
printf("%c no letra|digito \n", carac);

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

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

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

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

Determina si el argumento es una


minúscula. Devuelve un valor distinto if(islower(c)) printf"%c es una letra
islower(c) int ctype.h int islower(char c);
de cero si es cierto; en otro caso minúscula\n",c);
devuelve 0

Determina si el argumento es un digito


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

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

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

Determina si el argumento es una


mayúscula. Devuelve un valor distinto
isupper(c) int ctype.h int isupper(char c); if(isupper(c)) printf"%c es una mayúscula\n",c);
de cero si es cierto; en otro caso
devuelve 0

Determina si el argumento es un digito


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

Convierte el valor del argumento a


toascii int ctype.h int toascii(int c); c=toascii(entero);
ASCII

ctype.h o
tolower int int tolower(char c); Convierte una letra a minúscula c=tolower('s'); //c se convierte en 's'
stdlib.h
ctype.h o
toupper int int toupper(char c); Convierte una letra a mayúscula c=toupper('s'); //c se convierte en 'S'
stdlib.h

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

Reserva memoria para una formación


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

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 angulo = asin(0.707); // aproximadamente phi/4

Devuelve la arco tangente de d. Calcula


double atan(double d);
el arco tangente del argumento x.
atan(d) double math.h long double tanl(long angulo atan(1.0); // angulo es phi/4
Requiere el llamado de la biblioteca
double d);
complex.h
double atan(double d1,
atan(d1, d2) double math.h Devuelve el arco tangente de d1/d2 angulo = atan(y, x)
double d2);

Devuelve un valor redondeado por


ceil(d) double math.h double ceil(double d); redondeo=ceil(5.1); //redondeo es 6
exceso al siguiente entero mayor

double cos(double d);


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

double cos(double d); d=1.00;


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

Eleve e a la potencia d (e=2,7182818... d=100.00;


double exp(double d);
exp(d) double math.h es la base del sistema de logaritmos y=exp(d);
complex exp(complex d)
naturales (neperianos)) printf("El exponencial de x=%f.\n\n",y);

fabs(d) double math.h double fabs(double d); Devuelve el valor absoluto de d y=fabs(-7.25); // y vale 7.25

Devuelve un valor redondeado por


floor(d) double math.h double floor(double d); x=floor(6.25); // x vale 6
defecto al entero menor más cercano

double fmod(double d1, Devuelve el resto de d1/d2 (con el


fmod(d1, d2) double math.h resto=fmod(5.0,2.0); // resto igual a 1.0
double d2); mismo signo que d1)

int fscanf(FILE *f, const


Lee datos del archivo f ( el resto de los
fscanf(f, ...) int math.h char *formato, [, fscanf(flujo, %s%f, cad, &f);
argumentos
direccion,... ]);
long lx=-51654,ly;
labs(l) long int math.h long int labs(long int l); Devuelve el calor absoluto de 1
ly=labs(lx);

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

hdouble x,y;
log10(d) double math.h double log10(double d); Devuelve el logaritmo (en base 10) de d x=10;
y=log10(x);

double pow(double d1, double x=2.0, y=4.0, z;


pow(d1, d2) double math.h Devuelve d1 elevado a la potencia d2
double d2); z=pow(x,y); //z será 1.60

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

sinh(d) double math.h double sinh(double d); Devuelve el seno hiperbólico de d y=sinh(x);

sqrt(d) double math.h double sqrt(double d); Devuelve la raíz cuadrada de d printf("%lf",sqrt(25.0); //se visualiza 5

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

tanh(d) double math.h double tanh(double d); Devuelve la tangente hiperbólica de d a=tanh(x);
Cierra el archivo f. Devuelve el valor 0 si
fclose(f) int stdio.h int fclose(FILE *f); int fclose(FILE "archivo");
el archivo se ha cerrado con éxito.

char *fgets(char s, int s, Lee una cadena s, con i caracteres, del


fegts(s, i, f) char(puntero) stdio.h fgets(caddemo, 80, fp);
FILE *f); archivo f

Determina si se ha encontrado un fin


de archivo. si es así, devuelve un valor
feof(f) int stdio.h int feof(FILE *f); feof(fichen);
distinto de cero, en otro caso devuelve
0

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

int fprintf(FILE *f, const Escribe datos en el archivo f (el resto de


fprintf(f, ...) int stdio.h fprintf(f1, "El resultado es %f\n",result);
char *formato [,arg,...]); los argumentos

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

int fputs(const char *cad, Escribe una cadena de caracteres en el


fputs(s, f) int stdio.h fputs("esto es una prueba", f1);
FILE *f) archivo f

Lee i2 elementos, cada uno de tamaño


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

Devuelve la posición actual del puntero


ftell(f) long int stdio.h long int ftell(FILE *f); ftell(fichen)
dentro del archivo f
Abre un archivo llamado s1, del tipo s2.
Devuelve un puntero al archivo. *
Modo Acción
"r" Abre para lectura
Abre un archivo vacío para
"w"
escritura
Abre para escritura al final
"a"
del archivo
"r+" Abre para lectura/escritura
Abre un archivo vacío para
"w+"
lectura/escritura
FILE *fopen(const char if (corriente2=fopen("datos","W+")==NULL)
fopen(s1, s2) file(puntero) stdio.h "a+" Abre para lectura y añadir
*s1, const char *s2) printf("El archivo...no se ha abierto \n");
Abre un archivo binario para
"rb"
lectura.
Abre un archivo binario para
"wb"
escritura
Abre un archivo binario para
"ab"
añadir
Abre un archivo binario para
"rb+"
lectura/escritura.
Abre un archivo binario para
"wb+"
lectura/escritura
Abre o crea un archivo
"ab+"
binario para lectura/escritura
Mueve el puntero al archivo f una
distancia de 1 bytes desde la posición i
(i puede representar el principio del
archivo, la posición actual del puntero o
el fin del archivo.
Notas

int fseek(FILE *f, long


fseek(f, l, i) int stdio.h Origen Significado fseek(f1,OL,SEEK_SET); // ir al principio
desplaza, int origen);

SEEK_SET Principio de archivo

Posición actual
SEEK_CUR
puntero

SEEK_END Final del archivo

size_t fwrite(const void Escribe i2 elementos, cada uno de


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

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

int c;
Lee un caracter desde el dispositivo de
getchar( ) int stdio.h int getchar(void); while((*c=getchar()) != '\n')
entrada estándar
print ("%c",c);
Lee una cadena de caracteres desde el
gets(s) char(puntero) stdio.h char *gets(char *cad); gets(nombre);
dispositivo de entrada estándar

Escribe datos en dispositivo de salida


estándar.

Código Formato

%c Caracter

%d Entero Decimal

int printf(const char Real (double o float),


printf(...) int stdio.h %e printf("producto %d y %d es %d\n",x,y,x*y);
*formato[,argumento,...]); notación científica.

%f Coma flotante

%s Cadena de caracteres

%x Hexadecimal sin signo

Dirección de memoria,
%p
puntero

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

Escribe un caracter en el dispositivo de


putchar(c) int stdio.h int putchar(int c); putchar('B');
salida estándar
Escribe una cadena de caracteres en el
puts(s) int stdio.h int puts(const char *cad) puts("Desea continuar (s/n);
dispositivo de salida estándar

Mueve el puntero al principio del


rewind(f) void stdio.h void rewind(FILE *f); rewind(fx);
archivo f

Lee datos en dispositivo de entrada


estándar

Código Formato

%c Caracter

%d Entero Decimal

int scanf(const char


scanf(...) int stdio.h %x Hexadecimal scanf('%d %f %c %s, &i, &fp, &c, s);
*formato {,direccion,...]);
%i Entero Decimal

%f Número Real

%o Octal

%p Puntero

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

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

Convierte la cadena s a un entero. int i;


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

Convierte la cadena s a un entero largo. long int i;


La cadena debe tener el siguiente char cad_ent="9876543";
long atol(const char
atol(s) long stdlib.h formato: ...
*cadena);
[espacio en blanco][signo][ddd] (siendo i=atol(cad_ent); //convierte la cadena
obligatorio los dígitos decimales). "9876543" al entero largo

Cierra todos los archivos y buffers y


termina el programa. El valor de u es
exit(u) void stdlib.h void exit(int estado) exit(0);
asignado por la función para indicar el
estado de terminación.

Reserva u bytes de memoria. devuelve


malloc(u) void(puntero) stdlib.h void *malloc(size_t u); un puntero al principio del espacio cadena=malloc(MAX_CHR);
reservado
// visualizar 10 números aleatorios

rand( ) int stdlib.h int rand(void); Devuelve un entero positivo aleatorio


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

Inicializa el generador de números


srand(u) void stdlib.h void srand(unsigned u); srand(semilla);
aleatorios

i=strcmp("MNP", "mnp"); // resultado < 0


i=strcmp("abc", "abc"); // resultado = 0
Compara dos cadenas de caracteres
i=strcmp("xy", "abc"); // resultado > 0
int strcmp(const char*s1, lexicográficamente. Devuelve un valor
strcmp(s1, s2) int string.h
const char *s2); negativo si s1 < s2; 0 si s1 y s2 son
char s1[80]="Mayo";
idénticas; y un valor positivo si s1 > s2
char s2[80]="Octubre";
int j;
j=strcmp(s1,s2);
Compara dos cadenas de caracteres
lexicográficamente, sin diferenciar
int strcmpi(const char*s1,
strcmpi(s1, s2) int string.h mayúsculas de minúsculas. Devuelve un v=strcmpi(s1,s2);
const char *s2);
valor negativo si s1 < s2; 0 si s1 y s2 son
idénticas; y un valor positivo si s1 > s2

char *s1="Pepe Luis";


char *strcpy(char s1, Copia la cadena de caracteres s2 en la
strcpy(s1, s2) char string.h char b[12];
const char s2); cadena s1
strcpy(s2,s1);
cout <<s2<< '\n';
size_t strlen(const char Devuelve el número de caracteres de longitud=strlen(nombre);
strlen(s) int string.h
*s); una cadena char s[81]="Cadena demo';
printf("La longitud de s es: %d\n" strlen(s));

Pone todos los caracteres de s a c


char *strset(char *cad, int char *cad="----";
strset(c, s) char(puntero) string.h (excluyendo el caracter nulo del final
c); strset (cad,'x'); // cad es ahora xxxx
\0)

Pasa la orden al sistema operativo.


Devuelve cero si la orden se ejecuta
system(s) int string.h system(comd); correctamente; en otro caso devuelve system(dir);
un valor distinto de cero, típicamente -
1.

time_t inicio, fin;


Devuelve la diferencia de tiempo clrscrl();
11(hora2) - 12(hora1) , donde 11 y 12 inicio=time(NULL);
double difftime(time_t
difftime(11, 12) double time.h representan el tiempo transcurrido delay(5000)
hora2, time_t hora1)
después de un tiempo base (ver función fin=time(NULL)
time) printf("Diferencia en segundos: %f\n",
difftime(inicio,fin));

Devuelve el número de segundos


time(p) long int time.h time_t time(time_t *h); transcurridos después de un tiempo time(&hora);
base designado