When we write C language programs, whether implementing a simple string processing function or building a complex system-level application, we rely on a series of basic yet powerful utility functions—such as reading files, manipulating strings, sorting arrays, managing memory, and obtaining time, among others. These functionalities are typically not implemented from scratch; instead, we depend on the standard toolkit provided by the C language, known as the C Standard Library.
The C Standard Library is the most fundamental, general, and standardized collection of functions in the C language ecosystem. It is defined by international standards of the C language (such as C89/C90, C99, C11, C17, C23) and covers almost all basic functionalities required for daily programming, including input/output, string processing, mathematical operations, memory management, date and time, character processing, and sorting/searching. It is not only the most commonly used tool in the daily development of C programmers but also the cornerstone of cross-platform development, engineering practices, system programming, and low-level development.
Unlike many high-level languages that come with large frameworks, the C Standard Library is designed with the philosophy of being “small yet precise, efficient yet general.” It does not rely on complex runtime environments nor impose specific programming paradigms, but instead provides developers with a set of clear interfaces, consistent behaviors, and strong portability. Mastering the C Standard Library not only allows you to write more efficient and reliable code but also helps you gain a deeper understanding of the design philosophy, standards, and engineering practices of the C language.
In this article, we will delve into the core modules, commonly used functions, classification system, usage tips, and best practices of the C Standard Library, helping you systematically master this fundamental and crucial toolkit in C language development, providing solid support for your coding journey.
1.<stdio.h>: Input and Output
· printf(), scanf()· fopen(), fread(), fwrite(), fclose()1. Standard Input and Output Functions (Console I/O)
printf() formats output to standard output (usually the screen)
#include <stdio.h>
int main() { int age = 25; float height = 1.75; char name[] = "Alice";
printf("Name: %s\n", name); // Output string printf("Age: %d\n", age); // Output integer printf("Height: %.2f meters\n", height); // Output float, keeping two decimal places
return 0;}scanf() reads formatted data from standard input (usually the keyboard)
#include <stdio.h>
int main() { int num; float f; char str[100];
printf("Enter an integer: "); scanf("%d", &num); // Note & for address
printf("Enter a float: "); scanf("%f", &f);
printf("Enter a string: "); scanf("%s", str); // The name of the character array itself represents the address, no need for &.
printf("\nYou entered:\n"); printf("Integer: %d\n", num); printf("Float: %.2f\n", f); printf("String: %s\n", str);
return 0;}⚠️ Note:· For basic types (like int, float), you need to pass the address of the variable, i.e., use &.· For strings (character arrays), the array name itself points to the first element, so no & is needed.· scanf() has strict input format requirements and is not flexible; it is recommended to consider using fgets() + parsing for complex inputs.2.File Operation Functions (File I/O)
fopen() opens a file
FILE *fp = fopen("example.txt", "r");if (fp == NULL) { perror("Failed to open file"); return 1;}// Use fp...fclose() closes a file
fclose(fp); // Remember to close the file! Otherwise, it may lead to data loss or resource leaks.fread() reads a block of data from a file
#include <stdio.h>
int main() { FILE *fp = fopen("data.bin", "rb"); // Open in binary read mode if (!fp) { perror("Failed to open file"); return 1; } int buffer[5]; size_t items_read = fread(buffer, sizeof(int), 5, fp); printf("Read %zu integers from file:\n", items_read); for (size_t i = 0; i < items_read; i++) { printf("%d ", buffer[i]); } fclose(fp); return 0;}fwrite() writes a block of data to a file
#include <stdio.h>
int main() { int data[] = {10, 20, 30, 40, 50}; FILE *fp = fopen("data.bin", "wb"); // Open in binary write mode if (!fp) { perror("Failed to open file"); return 1; } size_t items_written = fwrite(data, sizeof(int), 5, fp); printf("Successfully wrote %zu integers to file.\n", items_written); fclose(fp); return 0;}2.<stdlib.h>: General Utility Functions
· Memory allocation: malloc(), calloc(), free(), realloc()· Conversion: atoi(), atof(), strtol(), etc.· System commands: system("cmd")1.Dynamic Memory Management Functions
malloc() allocates uninitialized memory of a specified number of bytes
#include <stdio.h>
#include <stdlib.h>
int main() { int n = 5; int *arr = (int *)malloc(n * sizeof(int)); // Allocate space for 5 ints if (arr == NULL) { printf("Memory allocation failed!\n"); return 1; } // Use memory (uninitialized, values are uncertain) for (int i = 0; i < n; i++) { arr[i] = i + 1; // Assign values } for (int i = 0; i < n; i++) { printf("%d ", arr[i]); // Output: 1 2 3 4 5 } free(arr); // Must manually free! return 0;}calloc() allocates and initializes memory to 0
#include <stdio.h>
#include <stdlib.h>
int main() { int n = 5; int *arr = (int *)calloc(n, sizeof(int)); // Allocate and zero out if (arr == NULL) { printf("Memory allocation failed!\n"); return 1; } // Output should be 0 0 0 0 0 for (int i = 0; i < n; i++) { printf("%d ", arr[i]); // All zeros } free(arr); return 0;}free() releases dynamically allocated memory
free(ptr); // Free memory pointed to by ptrptr = NULL; // Optional: avoid dangling pointerrealloc() adjusts the size of an allocated memory block
#include <stdio.h>
#include <stdlib.h>
int main() { int *arr = (int *)malloc(3 * sizeof(int)); if (!arr) return 1; arr[0] = 10; arr[1] = 20; arr[2] = 30; // Expand to 5 ints int *new_arr = (int *)realloc(arr, 5 * sizeof(int)); if (!new_arr) { free(arr); // Original memory must be freed if realloc fails return 1; } arr = new_arr; // Use new pointer arr[3] = 40; arr[4] = 50; for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); // 10 20 30 40 50 } free(arr); return 0;}2.String and Number Conversion Functions
atoi() converts string to int (does not check for errors)
#include <stdio.h>
#include <stdlib.h>
int main() { int num = atoi("12345"); printf("%d\n", num); // 12345 num = atoi("abc123"); // Conversion fails, returns 0 printf("%d\n", num); // 0}atof() converts string to double
double d = atof("3.14");printf("%f\n", d); // 3.140000strtol() a safer and more powerful string to long conversion (recommended)
#include <stdio.h>
#include <stdlib.h>
int main() { const char *str = "12345abc"; char *end; long num = strtol(str, &end, 10);
printf("Converted: %ld\n", num); // 12345 printf("Remaining: %s\n", end); // "abc"
return 0;}3. Executing System Commands
#include <stdio.h>
#include <stdlib.h>
int main() { printf("Opening calculator...\n"); int ret = system("calc"); // Open calculator on Windows int ret = system("gnome-calculator"); // Linux int ret = system("open -a Calculator"); // macOS
printf("Command exited with status: %d\n", ret); return 0;}3.<string.h>: String Operations
· strcpy(), strncpy(), strcat(), strlen()· strcmp(), strstr(), memcpy(), memset()1. String Operation Functions (String Functions)
strlen() gets the length of a string
#include <stdio.h>
#include <string.h>
int main() { const char *s = "Hello"; printf("Length: %zu\n", strlen(s)); // 5 return 0;}strcpy() copies a string (source → destination)
#include <stdio.h>
#include <string.h>
int main() { char src[] = "Hello, strcpy!"; char dest[50];
strcpy(dest, src); printf("Copied: %s\n", dest); // Hello, strcpy! return 0;}strncpy() a safer string copy (limits the maximum number of characters copied)
#include <stdio.h>
#include <string.h>
int main() { char src[] = "Hello"; char dest[10];
strncpy(dest, src, 5); // Only copy the first 5 characters dest[5] = '\0'; // Manually add the null terminator! printf("Dest: %s\n", dest); // Hello
return 0;}strcat() concatenates strings (joins)
#include <stdio.h>
#include <string.h>
int main() { char dest[50] = "Hello, "; const char *src = "world!"; strcat(dest, src); printf("%s\n", dest); // Hello, world! return 0;}2.String Comparison and Search
strcmp() compares strings
#include <stdio.h>
#include <string.h>
int main() { const char *s1 = "apple"; const char *s2 = "banana";
int result = strcmp(s1, s2); if (result < 0) printf("\"%s\" comes before \"%s\"\n", s1, s2); // This will output else if (result > 0) printf("\"%s\" comes after \"%s\"\n", s1, s2); else printf("Strings are equal\n");
return 0;}strstr() searches for a substring in a string
#include <stdio.h>
#include <string.h>
int main() { const char *text = "Hello, world!"; const char *sub = "world";
char *result = strstr(text, sub); if (result) printf("Found at: %s\n", result); // world! else printf("Substring not found.\n");
return 0;}3. Memory Operation Functions (Memory Functions)
memcpy() copies a block of memory
#include <stdio.h>
#include <string.h>
int main() { int src[] = {1, 2, 3, 4}; int dest[4];
memcpy(dest, src, sizeof(src));
for (int i = 0; i < 4; i++) printf("%d ", dest[i]); // 1 2 3 4
return 0;}memset() fills a block of memory
#include <stdio.h>
#include <string.h>
int main() { char str[10]; memset(str, '*', 5); // Set the first 5 bytes to '*' str[5] = '\0'; // Manually add the null terminator printf("%s\n", str); // *****
return 0;}4.<math.h>: Mathematical Functions
· sqrt(), pow(), sin(), cos(), etc.1.sqrt() calculates the square root
#include <stdio.h>
#include <math.h>
int main() { double num = 25.0; double result = sqrt(num); printf("The square root of %.2f is %.2f\n", num, result); // 5.00 return 0;}2.pow() calculates power (exponentiation)
#include <stdio.h>
#include <math.h>
int main() { double base = 2.0; double exp = 3.0; double result = pow(base, exp); // 2^3 = 8 printf("%.2f raised to the power of %.2f = %.2f\n", base, exp, result); // 8.00 return 0;}3.sin() calculates the sine value
#include <stdio.h>
#include <math.h>
int main() { double angle_rad = 3.1415926535 / 2; // π/2 ≈ 90 degrees double result = sin(angle_rad); printf("sin(π/2) = %.2f\n", result); // Approximately 1.00 return 0;}4.cos() calculates the cosine value
#include <stdio.h>
#include <math.h>
#define PI 3.1415926535
int main() { double angle_rad = 0.0; // 0 radians = 0° double result = cos(angle_rad); printf("cos(0) = %.2f\n", result); // 1.00
double degree_60 = 60.0; double rad_60 = degree_60 * (PI / 180.0); printf("cos(60°) = %.2f\n", cos(rad_60)); // Approximately 0.50 return 0;}5.<time.h>: Time Handling
· time(), clock(), sleep(), localtime(), strftime()1. time() gets the current calendar time (timestamp)
#include <stdio.h>
#include <time.h>
int main() { time_t now; time(&now); // Get current timestamp
printf("Current timestamp: %ld\n", (long)now); return 0;}2.clock() gets the processor time used by the program
#include <stdio.h>
#include <time.h>
int main() { clock_t start, end; double cpu_time_used;
start = clock(); // Record start time
// Simulate time-consuming operation for (int i = 0; i < 100000000; i++);
end = clock(); // Record end time cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
printf("CPU Time used: %f seconds\n", cpu_time_used); return 0;}3.sleep() makes the program sleep / delay (pause execution)
#include <stdio.h>
#include <unistd.h> // sleep() for Linux/Mac
int main() { printf("Start sleeping...\n"); sleep(3); // Sleep for 3 seconds printf("Awake after 3 seconds!\n"); return 0;}#include <stdio.h>
#include <windows.h> // Sleep() for Windows
int main() { printf("Start sleeping...\n"); Sleep(3000); // Sleep for 3000 milliseconds = 3 seconds printf("Awake after 3 seconds!\n"); return 0;}4.localtime() converts timestamp to local time structure
#include <stdio.h>
#include <time.h>
int main() { time_t now; time(&now); // Current timestamp
struct tm *local = localtime(&now); // Convert to local time structure
printf("Local time: %04d-%02d-%02d %02d:%02d:%02d\n", local->tm_year + 1900, // Year local->tm_mon + 1, // Month local->tm_mday, // Day local->tm_hour, // Hour local->tm_min, // Minute local->tm_sec); // Second
return 0;}5.strftime() formats time output as a custom string
#include <stdio.h>
#include <time.h>
int main() { time_t now; time(&now); struct tm *local = localtime(&now);
char buffer[80]; strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", local);
printf("Formatted time: %s\n", buffer); // Output like: 2025-11-10 03:13:45 return 0;}6.<ctype.h>: Character Handling
· isalpha(), isdigit(), tolower(), toupper(), etc.1. isalpha() checks if a character is a letter
#include <stdio.h>
#include <ctype.h>
int main() { char c1 = 'A'; char c2 = '5'; char c3 = 'z';
printf("'%c' is alpha? %d\n", c1, isalpha(c1)); // 1 (true) printf("'%c' is alpha? %d\n", c2, isalpha(c2)); // 0 (false) printf("'%c' is alpha? %d\n", c3, isalpha(c3)); // 1 (true)
return 0;}2.isdigit() checks if a character is a digit
#include <stdio.h>
#include <ctype.h>
int main() { char c1 = '7'; char c2 = 'A'; char c3 = '0';
printf("'%c' is digit? %d\n", c1, isdigit(c1)); // 1 printf("'%c' is digit? %d\n", c2, isdigit(c2)); // 0 printf("'%c' is digit? %d\n", c3, isdigit(c3)); // 1
return 0;}3.tolower() converts uppercase letters to lowercase letters
#include <stdio.h>
#include <ctype.h>
int main() { char c1 = 'A'; char c2 = 'z'; char c3 = '1';
printf("'%c' -> '%c'\n", c1, tolower(c1)); // 'A' -> 'a' printf("'%c' -> '%c'\n", c2, tolower(c2)); // 'z' -> 'z' printf("'%c' -> '%c'\n", c3, tolower(c3)); // '1' -> '1'
return 0;}4.toupper() converts lowercase letters to uppercase letters
#include <stdio.h>
#include <ctype.h>
int main() { char c1 = 'a'; char c2 = 'Z'; char c3 = '9';
printf("'%c' -> '%c'\n", c1, toupper(c1)); // 'a' -> 'A' printf("'%c' -> '%c'\n", c2, toupper(c2)); // 'Z' -> 'Z' printf("'%c' -> '%c'\n", c3, toupper(c3)); // '9' -> '9'
return 0;}The C Standard Library is the “standard answer library” and “toolbox” in the world of C language. It embodies the wisdom and experience of C language designers and countless developers over the years, providing us with efficient, general, portable, and validated basic functionalities. Mastering the C Standard Library means you can stand on the shoulders of giants, focusing more on business logic and innovation rather than reinventing the wheel.
Keep up the good work, comrades! The C Standard Library is not only the cornerstone of learning the C language but also an important ladder to a broader programming world, more efficient engineering practices, and a more professional coding style. Every call you make is a respect for standards and norms; every deep dive you take is an understanding of the essence of the C language.