stdio.h

The stdio.h library in C provides functionalities for input and output operations. Here are some of the important functions provided by stdio.h with examples:

printf

• Prints formatted output to the standard output (stdout).
• Syntax: int printf(const char *format, ...)

#include 

int main() {
    printf("Hello, World!\n");  // Output: Hello, World!
    printf("Number: %d\n", 10); // Output: Number: 10
    return 0;
}

scanf

• Reads formatted input from the standard input (stdin).
• Syntax: int scanf(const char *format, ...)

#include 

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);
    printf("You entered: %d\n", num);
    return 0;
}

gets

• Reads a line from stdin into the buffer pointed to by s until a newline character or EOF is encountered.
• Syntax: char *gets(char *s)

#include 

int main() {
    char str[100];
    printf("Enter a string: ");
    gets(str);
    printf("You entered: %s\n", str);
    return 0;
}

fgets

• Reads a line from the specified stream and stores it into the string pointed to by s. Reading stops after an n-1 characters or a newline.
• Syntax: char *fgets(char *s, int n, FILE *stream)

#include 

int main() {
    char str[100];
    printf("Enter a string: ");
    fgets(str, 100, stdin);
    printf("You entered: %s\n", str);
    return 0;
}

putchar

• Writes a character to the standard output (stdout).
• Syntax: int putchar(int char)

#include 

int main() {
    putchar('A');  // Output: A
    putchar('\n');
    return 0;
}

getchar

• Reads the next character from the standard input (stdin).
• Syntax: int getchar(void)

#include 

int main() {
    int c;
    printf("Enter a character: ");
    c = getchar();
    printf("You entered: %c\n", c);
    return 0;
}

puts

• Writes a string to the standard output (stdout) followed by a newline character.
• Syntax: int puts(const char *s)

#include 

int main() {
    puts("Hello, World!");  // Output: Hello, World!
    return 0;
}

fputs

• Writes a string to the specified stream.
• Syntax: int fputs(const char *s, FILE *stream)

#include 

int main() {
    fputs("Hello, World!\n", stdout);  // Output: Hello, World!
    return 0;
}

stdlib.h

The stdlib.h library in C provides various utility functions for performing general-purpose operations, including memory allocation, process control, conversions, and searching/sorting. Here are some of the important functions provided by stdlib.h with examples:

malloc

• Allocates a block of memory of a specified size.
• Syntax: void *malloc(size_t size)

#include 
#include 

int main() {
    int *arr;
    int n = 5;
    arr = (int *)malloc(n * sizeof(int));  // Allocates memory for 5 integers
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i 



calloc

Allocates a block of memory for an array of elements, initializing all bytes to zero.

Syntax: void *calloc(size_t num, size_t size)

#include 
#include 

int main() {
    int *arr;
    int n = 5;
    arr = (int *)calloc(n, sizeof(int));  // Allocates memory for 5 integers and initializes to zero
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i 



realloc

Changes the size of a previously allocated memory block.

Syntax: void *realloc(void *ptr, size_t size)

#include 
#include 

int main() {
    int *arr;
    int n = 5;
    arr = (int *)malloc(n * sizeof(int));  // Allocates memory for 5 integers
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i 



free

Frees the previously allocated memory.

Syntax: void free(void *ptr)

#include 

int main() {
    int *arr = (int *)malloc(5 * sizeof(int));
    // ... use the allocated memory ...
    free(arr);  // Frees the allocated memory
    return 0;
}




exit

Terminates the program.

Syntax: void exit(int status)

#include 
#include 

int main() {
    printf("Exiting the program\n");
    exit(0);  // Exits the program with a status code of 0
    printf("This line will not be executed\n");
    return 0;
}





  
  
  string.h


The string.h library in C provides functions for handling strings and performing various operations on them, such as copying, concatenation, comparison, and searching. Here are some of the important functions provided by string.h with examples:

strlen

Computes the length of a string.

Syntax: size_t strlen(const char *str)

#include 
#include 

int main() {
    char str[] = "Hello, world!";
    printf("Length of the string: %zu\n", strlen(str));  // Output: Length of the string: 13
    return 0;
}




strcpy

Copies a string to another.

Syntax: char *strcpy(char *dest, const char *src)

#include 
#include 

int main() {
    char src[] = "Hello, world!";
    char dest[50];
    strcpy(dest, src);
    printf("Copied string: %s\n", dest);  // Output: Copied string: Hello, world!
    return 0;
}




strncpy

Copies a specified number of characters from a source string to a destination string.

Syntax: char *strncpy(char *dest, const char *src, size_t n)

#include 
#include 

int main() {
    char src[] = "Hello, world!";
    char dest[50];
    strncpy(dest, src, 5);
    dest[5] = '\0';  // Null-terminate the destination string
    printf("Copied string: %s\n", dest);  // Output: Copied string: Hello
    return 0;
}




strcat

Appends a source string to a destination string.

Syntax: char *strcat(char *dest, const char *src)

#include 
#include 

int main() {
    char dest[50] = "Hello";
    char src[] = ", world!";
    strcat(dest, src);
    printf("Concatenated string: %s\n", dest);  // Output: Concatenated string: Hello, world!
    return 0;
}




strncat

Appends a specified number of characters from a source string to a destination string.

Syntax: char *strncat(char *dest, const char *src, size_t n)

#include 
#include 

int main() {
    char dest[50] = "Hello";
    char src[] = ", world!";
    strncat(dest, src, 7);
    printf("Concatenated string: %s\n", dest);  // Output: Concatenated string: Hello, world
    return 0;
}




strcmp

Compares two strings.

Syntax: int strcmp(const char *str1, const char *str2)

#include 
#include 

int main() {
    char str1[] = "Hello";
    char str2[] = "Hello";
    char str3[] = "World";
    printf("Comparison result: %d\n", strcmp(str1, str2));  // Output: Comparison result: 0
    printf("Comparison result: %d\n", strcmp(str1, str3));  // Output: Comparison result: -1 (or another negative value)
    return 0;
}




strncmp

Compares a specified number of characters of two strings.

Syntax: int strncmp(const char *str1, const char *str2, size_t n)

#include 
#include 

int main() {
    char str1[] = "Hello";
    char str2[] = "Helium";
    printf("Comparison result: %d\n", strncmp(str1, str2, 3));  // Output: Comparison result: 0
    printf("Comparison result: %d\n", strncmp(str1, str2, 5));  // Output: Comparison result: -1 (or another negative value)
    return 0;
}




strchr

Searches for the first occurrence of a character in a string.

Syntax: char *strchr(const char *str, int c)

#include 
#include 

int main() {
    char str[] = "Hello, world!";
    char *ptr = strchr(str, 'w');
    if (ptr != NULL) {
        printf("Character found: %s\n", ptr);  // Output: Character found: world!
    } else {
        printf("Character not found\n");
    }
    return 0;
}




strrchr

Searches for the last occurrence of a character in a string.

Syntax: char *strrchr(const char *str, int c)

#include 
#include 

int main() {
    char str[] = "Hello, world!";
    char *ptr = strrchr(str, 'o');
    if (ptr != NULL) {
        printf("Last occurrence of character found: %s\n", ptr);  // Output: Last occurrence of character found: orld!
    } else {
        printf("Character not found\n");
    }
    return 0;
}




strstr

Searches for the first occurrence of a substring in a string.

Syntax: char *strstr(const char *haystack, const char *needle)

#include 
#include 

int main() {
    char str[] = "Hello, world!";
    char *ptr = strstr(str, "world");
    if (ptr != NULL) {
        printf("Substring found: %s\n", ptr);  // Output: Substring found: world!
    } else {
        printf("Substring not found\n");
    }
    return 0;
}





  
  
  ctype.h


The ctype.h library in C provides functions for character classification and conversion. These functions help to determine the type of a character (such as whether it is a digit, letter, whitespace, etc.) and to convert characters between different cases.

Here are some of the important functions provided by ctype.h with examples:

isalpha

Checks if the given character is an alphabetic letter.

Syntax: int isalpha(int c)

#include 
#include 

int main() {
    char ch = 'A';
    if (isalpha(ch)) {
        printf("%c is an alphabetic letter\n", ch);  // Output: A is an alphabetic letter
    } else {
        printf("%c is not an alphabetic letter\n", ch);
    }
    return 0;
}




isdigit

Checks if the given character is a digit.

Syntax: int isdigit(int c)

#include 
#include 

int main() {
    char ch = '9';
    if (isdigit(ch)) {
        printf("%c is a digit\n", ch);  // Output: 9 is a digit
    } else {
        printf("%c is not a digit\n", ch);
    }
    return 0;
}




isalnum

Checks if the given character is an alphanumeric character.

Syntax: int isalnum(int c)

#include 
#include 

int main() {
    char ch = 'a';
    if (isalnum(ch)) {
        printf("%c is an alphanumeric character\n", ch);  // Output: a is an alphanumeric character
    } else {
        printf("%c is not an alphanumeric character\n", ch);
    }
    return 0;
}




isspace

Checks if the given character is a whitespace character.

Syntax: int isspace(int c)

#include 
#include 

int main() {
    char ch = ' ';
    if (isspace(ch)) {
        printf("The character is a whitespace\n");  // Output: The character is a whitespace
    } else {
        printf("The character is not a whitespace\n");
    }
    return 0;
}




isupper

Checks if the given character is an uppercase letter.

Syntax: int isupper(int c)

#include 
#include 

int main() {
    char ch = 'Z';
    if (isupper(ch)) {
        printf("%c is an uppercase letter\n", ch);  // Output: Z is an uppercase letter
    } else {
        printf("%c is not an uppercase letter\n", ch);
    }
    return 0;
}




islower

Checks if the given character is a lowercase letter.

Syntax: int islower(int c)

#include 
#include 

int main() {
    char ch = 'z';
    if (islower(ch)) {
        printf("%c is a lowercase letter\n", ch);  // Output: z is a lowercase letter
    } else {
        printf("%c is not a lowercase letter\n", ch);
    }
    return 0;
}




toupper

Converts a given character to its uppercase equivalent if it is a lowercase letter.

Syntax: int toupper(int c)

#include 
#include 

int main() {
    char ch = 'a';
    char upper = toupper(ch);
    printf("Uppercase of %c is %c\n", ch, upper);  // Output: Uppercase of a is A
    return 0;
}




tolower

Converts a given character to its lowercase equivalent if it is an uppercase letter.

Syntax: int tolower(int c)

#include 
#include 

int main() {
    char ch = 'A';
    char lower = tolower(ch);
    printf("Lowercase of %c is %c\n", ch, lower);  // Output: Lowercase of A is a
    return 0;
}





  
  
  math.h


The math.h library in C provides functions for mathematical computations. These functions allow operations like trigonometry, logarithms, exponentiation, and more. Here are some important functions provided by math.h with examples:

Trigonometric Functions

sin

Computes the sine of an angle (in radians).

Syntax: double sin(double x)

#include 
#include 

int main() {
    double angle = 0.5;
    double result = sin(angle);
    printf("sin(0.5) = %.4f\n", result);  // Output: sin(0.5) = 0.4794
    return 0;
}




cos

Computes the cosine of an angle (in radians).

Syntax: double cos(double x)

#include 
#include 

int main() {
    double angle = 0.5;
    double result = cos(angle);
    printf("cos(0.5) = %.4f\n", result);  // Output: cos(0.5) = 0.8776
    return 0;
}




tan

Computes the tangent of an angle (in radians).

Syntax: double tan(double x)

#include 
#include 

int main() {
    double angle = 0.5;
    double result = tan(angle);
    printf("tan(0.5) = %.4f\n", result);  // Output: tan(0.5) = 0.5463
    return 0;
}




Exponential and Logarithmic Functions

exp

Computes the base-e exponential function of x, e^x.

Syntax: double exp(double x)

#include 
#include 

int main() {
    double x = 2.0;
    double result = exp(x);
    printf("exp(2.0) = %.4f\n", result);  // Output: exp(2.0) = 7.3891
    return 0;
}




log

Computes the natural logarithm (base-e logarithm) of x.

Syntax: double log(double x)

#include 
#include 

int main() {
    double x = 10.0;
    double result = log(x);
    printf("log(10.0) = %.4f\n", result);  // Output: log(10.0) = 2.3026
    return 0;
}




pow

Computes x raised to the power of y (x^y).

Syntax: double pow(double x, double y)

#include 
#include 

int main() {
    double base = 2.0;
    double exponent = 3.0;
    double result = pow(base, exponent);
    printf("pow(2.0, 3.0) = %.4f\n", result);  // Output: pow(2.0, 3.0) = 8.0000
    return 0;
}




sqrt

Computes the square root of x.

Syntax: double sqrt(double x)

#include 
#include 

int main() {
    double x = 25.0;
    double result = sqrt(x);
    printf("sqrt(25.0) = %.4f\n", result);  // Output: sqrt(25.0) = 5.0000
    return 0;
}




Rounding and Remainder Functions

ceil

Computes the smallest integer value greater than or equal to x.

Syntax: double ceil(double x)

#include 
#include 

int main() {
    double x = 3.14;
    double result = ceil(x);
    printf("ceil(3.14) = %.4f\n", result);  // Output: ceil(3.14) = 4.0000
    return 0;
}




floor

Computes the largest integer value less than or equal to x.

Syntax: double floor(double x)

#include 
#include 

int main() {
    double x = 3.14;
    double result = floor(x);
    printf("floor(3.14) = %.4f\n", result);  // Output: floor(3.14) = 3.0000
    return 0;
}




round

Rounds x to the nearest integer value.

Syntax: double round(double x)

#include 
#include 

int main() {
    double x = 3.75;
    double result = round(x);
    printf("round(3.75) = %.4f\n", result);  // Output: round(3.75) = 4.0000
    return 0;
}