C Programming Language

Standard C Library Functions in c programming language

The C, C + + has many features, when using the standard library functions, increasing the portability of programs.

Standard functions are divided into groups, all functions that belong together are declared in the header file (the one that says xxx.h), the letter "h" for header in English and is called heading.

To include any function belonging to these headers should write lines of code as shown as an example:

# Include

I designed this table to study the function libraries are obviously I've found in my books and systems.

LIBRARIES AND USE DESCRIPTIONS

Library Name Description
assert.h Is to provide a definition of the assert macro, which prints an error message and aborts the program
alloc.h There are functions to allocate, free memory, or obtain information from the memory blocks.
ctype.h The functions that allow us to know the nature of a character, or to convert uppercase to lowercase and vice versa and integer values ​​to ASCII codes.
dir.h This lets you sort, create, modify, move and delete directories
errno.h Represent the numbers of error, an error occurs then you can query the value of the system varianble deerrno for more information about this error.
float.h Define the limits of the floating-point types
limits.h Define the boundaries of different types of integers
math.h Contains the standard math functions used in C and C + +
setjmp.h Defines the type of jmp_buf for some functions.
signal.h Contains state functions.
stdarg.h Defines functions that can be called with different numbers of arguments, so that they can write f (a) f (a, b).
stdef.h Define some special types
stdio.h Incorporate functions - Out E / S standard, types and macros
stlib.h Declare functions that are useful for different purposes, especially searching and sorting.
string.h This file contains functions for handling strings.
time.h Contains functions related to dates and times

Features Found in the Libraries

# 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 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'


c program stats