Common Errors in C Language: Pointer Errors and Memory Leaks

In C programming, pointers are a very important concept, but they can also lead to many common errors. This article will delve into pointer-related errors and memory leaks, and provide code examples to help everyone understand these issues.

What is a Pointer?

A pointer is a data type that holds the memory address of a variable. Using pointers allows direct manipulation of memory, thereby improving the efficiency and flexibility of programs. However, if they are not used correctly, they can lead to program crashes or abnormal behavior.

Examples of Pointer Errors

Null Pointer Dereference

When we try to access data through a null pointer, it will trigger a runtime error. This is a common and dangerous situation.

#include <stdio.h>
int main() {    int *ptr = NULL;  // Declare a null pointer    // Attempt to dereference the null pointer    printf("%d\n", *ptr);  // Error! Dereferencing a null pointer    return 0;}

Explanation: In the above code, ptr is initialized to NULL (indicating no valid address), but then we attempt to dereference this null address, which causes the program to crash. Therefore, it is essential to check if a pointer is null before using it.

Dangling Pointer

A dangling pointer refers to a memory address that has been freed or uninitialized but is still accessed. This is also a very dangerous operation.

#include <stdio.h>
#include <stdlib.h>
int main() {    int *ptr;    ptr = (int*)malloc(sizeof(int));  // Dynamically allocate memory
    if (ptr != NULL) {        *ptr = 10;     // Correct assignment        printf("%d\n", *ptr);        free(ptr);     // Use free to release memory                // Here ptr is a dangling pointer, no longer valid         printf("%d\n", *ptr);  // Error! Accessing freed memory               }   return 0;}

Explanation: In the above code, we dynamically allocated space for an integer variable and assigned a value. However, once the free() function is called, that segment of memory on the heap is no longer valid, and accessing that location again results in undefined behavior, which may lead to unexpected results.

What is a Memory Leak?

A memory leak occurs whenever we allocate a new block of memory using malloc(), calloc(), or other dynamic allocation functions, but lose all references to that block of memory without properly calling free(), which is referred to as a "memory leak".

Memory Leak Example

#include <stdlib.h>
void createMemoryLeak() {    int *leakPtr = (int*)malloc(sizeof(int));  // Allocate dynamic memory     // Note: free is not called here}
int main() {    createMemoryLeak();      // Once createMemoryLeak function ends, leakPtr is no longer controlled and cannot be freed, causing a memory leak.    return 0;}

Explanation: In this code, we create a function that dynamically allocates space for a single integer and never releases it. At this point, even though there are no further methods to query or manage this memory, it constitutes a “leak” situation. If this situation continues to occur, it will consume system resources and may eventually lead to process failure or degradation of computer performance. Therefore, regular checks and proper management are one of the solutions!

How to Avoid These Issues?

Always initialize your pointers to prevent arbitrary out-of-bounds access and dangling references.
Immediately free resources after allocating new blocks to avoid becoming a burden—ensure balance!
Consider the serious implications of external circular scheduling and deadlocks, and create structures to maintain a global context for historical reflection and better learning outcomes.

I hope this document can popularize the common mistakes in C language and help you understand the essential aspects of pointer management and memory allocation. Thank you for reading, and I appreciate your valuable suggestions and feedback!