Standard C library functions

The Standard C Library, often referred to as libc, is a collection of functions, macros, and types that provide basic functionalities to C programs. These functions are essential for performing common tasks like input/output operations, string manipulation, memory management, and mathematical computations. Understanding the Standard C Library is crucial for every C programmer as it simplifies the development process by providing pre-defined routines.

Including the Standard C Library

Before using functions from the Standard C Library, it’s essential to include the appropriate header files using the #include directive. For example:

				
					#include <stdio.h>  // for input/output operations
#include <stdlib.h> // for memory management
#include <string.h> // for string manipulation
#include <math.h>   // for mathematical functions

Including these header files allows access to various functions and types defined within them.

Input/Output Functions

One of the fundamental aspects of programming is input/output operations. The Standard C Library provides several functions for reading input from the user and displaying output to the screen.

				
					#include <stdio.h>

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

				
			
				
					// output //
Enter a number: 10
You entered: 10

In this example, printf() is used to display a message, scanf() is used to read input from the user, and %d is a format specifier used to specify the type of input.

String Manipulation Functions

String manipulation is a common task in programming. The Standard C Library provides functions to perform various operations on strings such as copying, concatenation, comparison, and searching.

				
					#include <stdio.h>
#include <string.h>

int main() {
    char str1[20] = "Hello";
    char str2[20] = " World!";
    char str3[20];
    int len;

    // strlen() - Calculates the length of a string
    len = strlen(str1);
    printf("Length of str1: %d\n", len);

    // strcpy() - Copies one string to another
    strcpy(str3, str1);
    printf("Copied string: %s\n", str3);

    // strcat() - Concatenates two strings
    strcat(str1, str2);
    printf("Concatenated string: %s\n", str1);

    // strcmp() - Compares two strings
    if (strcmp(str1, str2) == 0) {
        printf("Strings are equal\n");
    } else {
        printf("Strings are not equal\n");
    }

    // strchr() - Finds the first occurrence of a character in a string
    char *ptr = strchr(str1, 'W');
    printf("First occurrence of 'W': %s\n", ptr);

    // strstr() - Finds the first occurrence of a substring in a string
    ptr = strstr(str1, "World");
    printf("Substring found: %s\n", ptr);

    return 0;
}

				
			
				
					// output //
Length of str1: 5
Copied string: Hello
Concatenated string: Hello World!
Strings are not equal
First occurrence of 'W': World!
Substring found: World!

Explanation:

  1. strlen(): This function calculates the length of the string str1 and stores it in the variable len.

  2. strcpy(): It copies the content of str1 to str3, resulting in Hello being copied to str3.

  3. strcat(): Concatenates str2 to the end of str1, resulting in Hello World!.

  4. strcmp(): Compares str1 and str2. If they are equal, it prints that the strings are equal; otherwise, it prints that they are not equal.

  5. strchr(): Finds the first occurrence of character ‘W’ in str1 and returns a pointer to it.

  6. strstr(): Finds the first occurrence of substring "World" in str1 and returns a pointer to it.

Memory Management Functions

Dynamic memory management is a critical aspect of C programming, allowing programs to allocate and deallocate memory as needed. The Standard C Library provides several functions for dynamic memory management. Let’s explore these functions and illustrate their usage through a comprehensive example.

				
					#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr1, *ptr2, *ptr3;
    int n = 5;

    // malloc() - Allocates memory for n integers
    ptr1 = (int *)malloc(n * sizeof(int));

    if (ptr1 == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Assign values to the allocated memory
    for (int i = 0; i < n; i++) {
        ptr1[i] = i + 1;
    }

    // Display the values
    printf("Memory allocated using malloc():\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", ptr1[i]);
    }
    printf("\n");

    // calloc() - Allocates memory for n integers initialized to zero
    ptr2 = (int *)calloc(n, sizeof(int));

    if (ptr2 == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Display the values
    printf("Memory allocated using calloc():\n");
    for (int i = 0; i < n; i++) {
        printf("%d ", ptr2[i]);
    }
    printf("\n");

    // realloc() - Resizes the previously allocated memory to hold 10 integers
    ptr3 = (int *)realloc(ptr1, 10 * sizeof(int));

    if (ptr3 == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    // Assign additional values to the resized memory
    for (int i = n; i < 10; i++) {
        ptr3[i] = i + 1;
    }

    // Display the values after reallocation
    printf("Memory reallocated using realloc():\n");
    for (int i = 0; i < 10; i++) {
        printf("%d ", ptr3[i]);
    }
    printf("\n");

    // Free the allocated memory
    free(ptr2);
    free(ptr3);

    return 0;
}

				
			
				
					// output //
Memory allocated using malloc():
1 2 3 4 5 
Memory allocated using calloc():
0 0 0 0 0 
Memory reallocated using realloc():
1 2 3 4 5 6 7 8 9 10

Explanation:

  1. malloc(): Allocates memory for n integers (5 integers in this case) and initializes ptr1 to point to the allocated memory. Values are then assigned to this memory block.

  2. calloc(): Allocates memory for n integers initialized to zero. It returns a pointer (ptr2) to the allocated memory block. Since memory allocated by calloc() is initialized to zero, the output shows all zeros.

  3. realloc(): Resizes the previously allocated memory block (ptr1) to hold 10 integers. It returns a pointer (ptr3) to the resized memory block. Additional memory is allocated using realloc() to accommodate the new size. Values are assigned to the resized memory block.

  4. Displaying Values: The values stored in the memory blocks allocated by malloc(), calloc(), and realloc() are displayed.

  5. Freeing Memory: Finally, free() is used to release the dynamically allocated memory (ptr2 and ptr3) to prevent memory leaks.

Mathematical Functions

Mathematical functions play a crucial role in programming, facilitating various calculations ranging from basic arithmetic operations to complex mathematical computations. The Standard C Library provides a rich set of mathematical functions to cater to diverse needs. Let’s explore some of these functions in detail

				
					#include <stdio.h>
#include <math.h>

int main() {
    double num = 4.0;
    
    // Basic arithmetic functions
    printf("Square root of %f is %f\n", num, sqrt(num)); // Square root
    printf("Cube root of %f is %f\n", num, cbrt(num));   // Cube root
    
    // Trigonometric functions
    double angle = 45.0; // Angle in degrees
    double radian = angle * (M_PI / 180); // Convert angle to radians
    
    printf("Sine of %f degrees is %f\n", angle, sin(radian));   // Sine
    printf("Cosine of %f degrees is %f\n", angle, cos(radian)); // Cosine
    printf("Tangent of %f degrees is %f\n", angle, tan(radian)); // Tangent
    
    // Logarithmic functions
    printf("Natural logarithm of %f is %f\n", num, log(num));       // Natural logarithm (base e)
    printf("Base 10 logarithm of %f is %f\n", num, log10(num));     // Base 10 logarithm
    printf("Base 2 logarithm of %f is %f\n", num, log2(num));       // Base 2 logarithm
    
    // Exponential functions
    printf("Exponential function of %f is %f\n", num, exp(num)); // e raised to the power of num
    
    // Power function
    double base = 2.0;
    double exponent = 3.0;
    
    printf("%f raised to the power of %f is %f\n", base, exponent, pow(base, exponent));
    
    return 0;
}

				
			
				
					// output //
Square root of 4.000000 is 2.000000
Cube root of 4.000000 is 1.587401
Sine of 45.000000 degrees is 0.707107
Cosine of 45.000000 degrees is 0.707107
Tangent of 45.000000 degrees is 1.000000
Natural logarithm of 4.000000 is 1.386294
Base 10 logarithm of 4.000000 is 0.602060
Base 2 logarithm of 4.000000 is 2.000000
Exponential function of 4.000000 is 54.598150
2.000000 raised to the power of 3.000000 is 8.000000

Explanation:

  1. Basic arithmetic functions:

    • sqrt(): Calculates the square root of a number.
    • cbrt(): Calculates the cube root of a number.
 

  1. Trigonometric functions:

    • sin(): Calculates the sine of an angle (in radians).
    • cos(): Calculates the cosine of an angle (in radians).
    • tan(): Calculates the tangent of an angle (in radians).
    • Note: Angles are typically given in degrees, so conversion to radians is necessary.
 

  1. Logarithmic functions:

    • log(): Calculates the natural logarithm (base e) of a number.
    • log10(): Calculates the base 10 logarithm of a number.
    • log2(): Calculates the base 2 logarithm of a number.
 

  1. Exponential function:

    • exp(): Calculates the exponential function, which is e raised to the power of the given number.
 

  1. Power function:

    • pow(): Calculates the power of a number, given a base and an exponent.

Functions Reference

				
					| Header     | Function       | Description                                                               |
|------------|----------------|---------------------------------------------------------------------------|
| stdio.h    | printf()       | Prints formatted output to the console.                                   |
|            | scanf()        | Reads formatted input from the console.                                   |
|            | getchar()      | Reads a single character from the console.                               |
|            | putchar()      | Prints a single character to the console.                                |
| stdlib.h   | malloc()       | Allocates memory dynamically.                                             |
|            | calloc()       | Allocates memory for an array and initializes it with zero.               |
|            | realloc()      | Reallocates memory dynamically.                                           |
|            | free()         | Releases dynamically allocated memory.                                    |
|            | exit()         | Terminates the program execution immediately.                             |
| string.h   | strcpy()       | Copies one string to another.                                             |
|            | strcat()       | Concatenates two strings.                                                |
|            | strlen()       | Calculates the length of a string.                                        |
|            | strcmp()       | Compares two strings.                                                     |
|            | strchr()       | Returns a pointer to the first occurrence of a character in a string.    |
| math.h     | sqrt()         | Computes the square root of a number.                                     |
|            | pow()          | Computes the power of a number.                                           |
|            | sin(), cos(), tan() | Trigonometric functions.                                               |
|            | log(), log10() | Logarithmic functions.                                                    |
|            | ceil(), floor() | Rounds a number up or down to the nearest integer.                        |
| ctype.h    | isalpha()      | Checks if a character is an alphabet.                                     |
|            | isdigit()      | Checks if a character is a digit.                                         |
|            | isalnum()      | Checks if a character is an alphanumeric character.                       |
|            | toupper(), tolower() | Converts a character to uppercase or lowercase.                       |
|            | isspace()      | Checks if a character is a white-space character.                         |
|            | isupper(), islower() | Checks if a character is uppercase or lowercase.                      |
|            | isdigit()      | Checks if a character is a digit.                                         |
|            | isalpha()      | Checks if a character is an alphabet.                                     |
| time.h     | time()         | Returns the current calendar time.                                        |
|            | ctime()        | Converts a time value to a string representation.                        |
|            | difftime()     | Computes the difference between two time values.                          |
|            | strftime()     | Formats a time structure into a string.                                   |

The Standard C Library is a powerful tool for C programmers, providing a wide range of functions for various tasks. Understanding and mastering these functions is essential for developing efficient and robust C programs. By utilizing the functions provided by the Standard C Library, programmers can simplify their code, improve productivity, and create more maintainable software. Happy coding!❤️

Table of Contents

Home
Roadmap
AI
AI
Playground
Resources