C, Essential Libraries

Harsh Mishra - Jun 29 - - Dev Community

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 <stdio.h>

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

scanf

  • Reads formatted input from the standard input (stdin).
  • Syntax: int scanf(const char *format, ...)
#include <stdio.h>

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

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 <stdio.h>

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

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 <stdio.h>

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

putchar

  • Writes a character to the standard output (stdout).
  • Syntax: int putchar(int char)
#include <stdio.h>

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

getchar

  • Reads the next character from the standard input (stdin).
  • Syntax: int getchar(void)
#include <stdio.h>

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

puts

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

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

fputs

  • Writes a string to the specified stream.
  • Syntax: int fputs(const char *s, FILE *stream)
#include <stdio.h>

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

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 <stdio.h>
#include <stdlib.h>

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 < n; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);  // Output: 1 2 3 4 5
    }

    free(arr);  // Frees the allocated memory
    return 0;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <stdlib.h>

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 < n; i++) {
        printf("%d ", arr[i]);  // Output: 0 0 0 0 0
    }

    free(arr);  // Frees the allocated memory
    return 0;
}
Enter fullscreen mode Exit fullscreen mode

realloc

  • Changes the size of a previously allocated memory block.
  • Syntax: void *realloc(void *ptr, size_t size)
#include <stdio.h>
#include <stdlib.h>

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 < n; i++) {
        arr[i] = i + 1;
    }

    n = 10;  // Resize the array to hold 10 integers
    arr = (int *)realloc(arr, n * sizeof(int));
    if (arr == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    for (int i = 5; i < n; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);  // Output: 1 2 3 4 5 6 7 8 9 10
    }

    free(arr);  // Frees the allocated memory
    return 0;
}
Enter fullscreen mode Exit fullscreen mode

free

  • Frees the previously allocated memory.
  • Syntax: void free(void *ptr)
#include <stdlib.h>

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

exit

  • Terminates the program.
  • Syntax: void exit(int status)
#include <stdio.h>
#include <stdlib.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <string.h>

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

strcpy

  • Copies a string to another.
  • Syntax: char *strcpy(char *dest, const char *src)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strcat

  • Appends a source string to a destination string.
  • Syntax: char *strcat(char *dest, const char *src)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strcmp

  • Compares two strings.
  • Syntax: int strcmp(const char *str1, const char *str2)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strncmp

  • Compares a specified number of characters of two strings.
  • Syntax: int strncmp(const char *str1, const char *str2, size_t n)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strchr

  • Searches for the first occurrence of a character in a string.
  • Syntax: char *strchr(const char *str, int c)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strrchr

  • Searches for the last occurrence of a character in a string.
  • Syntax: char *strrchr(const char *str, int c)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

strstr

  • Searches for the first occurrence of a substring in a string.
  • Syntax: char *strstr(const char *haystack, const char *needle)
#include <stdio.h>
#include <string.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

isdigit

  • Checks if the given character is a digit.
  • Syntax: int isdigit(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

isalnum

  • Checks if the given character is an alphanumeric character.
  • Syntax: int isalnum(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

isspace

  • Checks if the given character is a whitespace character.
  • Syntax: int isspace(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

isupper

  • Checks if the given character is an uppercase letter.
  • Syntax: int isupper(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

islower

  • Checks if the given character is a lowercase letter.
  • Syntax: int islower(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

toupper

  • Converts a given character to its uppercase equivalent if it is a lowercase letter.
  • Syntax: int toupper(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

tolower

  • Converts a given character to its lowercase equivalent if it is an uppercase letter.
  • Syntax: int tolower(int c)
#include <stdio.h>
#include <ctype.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

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 <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

cos

  • Computes the cosine of an angle (in radians).
  • Syntax: double cos(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

tan

  • Computes the tangent of an angle (in radians).
  • Syntax: double tan(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

Exponential and Logarithmic Functions

exp

  • Computes the base-e exponential function of x, e^x.
  • Syntax: double exp(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

log

  • Computes the natural logarithm (base-e logarithm) of x.
  • Syntax: double log(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

pow

  • Computes x raised to the power of y (x^y).
  • Syntax: double pow(double x, double y)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

sqrt

  • Computes the square root of x.
  • Syntax: double sqrt(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

Rounding and Remainder Functions

ceil

  • Computes the smallest integer value greater than or equal to x.
  • Syntax: double ceil(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

floor

  • Computes the largest integer value less than or equal to x.
  • Syntax: double floor(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode

round

  • Rounds x to the nearest integer value.
  • Syntax: double round(double x)
#include <stdio.h>
#include <math.h>

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;
}
Enter fullscreen mode Exit fullscreen mode
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .