C code debugging: Types of bugs and 6-step debugging process

C is a highly efficient and flexible programming language that forms the basis of many modern languages. Its direct access to memory and low-level hardware makes it ideal for system-level programming. However, this also makes it susceptible to complex bugs that might be less common in higher-level languages.

C debugging is the process of identifying, diagnosing, and rectifying errors or bugs in your C code. These bugs may cause your software to behave unexpectedly or crash, leading to a poor user experience. Mastering debugging is an essential skill for every C programmer.

This is part of a series of articles about code debugging.

Common types of bugs in C 

Memory leaks

Memory leaks are a common type of bug in C programming. When you dynamically allocate memory using functions such as malloc(), calloc(), or realloc() and fail to free it when no longer needed, it leads to a memory leak. This bug is particularly insidious because it doesn’t usually cause a program to fail immediately. Instead, it subtly consumes the system’s memory, leading to slow performance over time. And if left unchecked, it may eventually cause the system to run out of memory.

Code example:

#include <stdlib.h>

int main() {

    int *ptr = (int *)malloc(sizeof(int) * 10); // Allocate memory for 10 integers

    // Perform some operations with ptr

    // Forget to free the memory

    // free(ptr);

    return 0;

}

In this example, we allocate memory for an array of 10 integers using malloc() but forget to free the memory with free(). This can eventually lead to a memory leak.

Buffer overflows

Another common bug in C programming is buffer overflow. This occurs when you attempt to store more data in a buffer (an array or a character string) than it was designed to hold. Buffer overflows can lead to erratic program behavior, including unexpected termination, incorrect results, or even a security vulnerability allowing malicious code execution.

Code example:

#include <string.h>

int main() {

    char buffer[10];

    strcpy(buffer, "This string is too long for the buffer");

    return 0;

}

In this example, we have a buffer that can hold 10 characters. We then attempt to copy a much longer string into it, which leads to a buffer overflow.

Modern C compilers throw a warning in these cases, as shown below:

Uninitialized variables

Uninitialized variables are yet another commonplace bug in C programming. Unlike some other programming languages, C does not automatically initialize variables. Therefore, if you declare a variable and use it without initializing it, the variable has an undefined value. This can lead to unpredictable program behavior, as the value of the uninitialized variable may change each time the program runs.

Code example:

#include <stdio.h>

int main() {

    int x;

    printf("%d\n", x);  // x is uninitialized

    return 0;

}

The variable x is declared but not initialized. When we attempt to print its value, it will contain some undefined data, or 0, depending on your compiler.

Array out-of-bounds access

In C programming, arrays are a fixed size, and the compiler does not check whether an index is within the bounds of the array. Therefore, a common bug is accessing an array out of its bounds, either reading from or writing to an invalid index. This can lead to incorrect results, program crashes, or overwriting unrelated data.

Code example:

#include <stdio.h>

int main() {

    int arr[5] = {1, 2, 3, 4, 5};

    printf("%d\n", arr[10]);  // Index out of bounds

    return 0;

}

In this example, we attempt to access an element at index 10 of an array that only has 5 elements, which results in out-of-bounds access.

Learn more in our detailed guide to VS Code Debugging.

C code debugging techniques 

Here are the basic techniques you can use to debug C code.

Using print statements

One of the most simple and straightforward techniques for C code debugging is using print statements. By inserting printf() statements at strategic points in your code, you can monitor the flow of your program and the state of important variables. While this technique may seem primitive, it is surprisingly effective and is often the first step in debugging.

Utilizing breakpoints

Utilizing breakpoints is another important technique in C code debugging. A breakpoint is a signal that tells the debugger to temporarily halt the execution of your program at a certain point. This allows you to inspect the state of your program, check the values of variables, and step through your code one line at a time to see exactly where things go wrong.

Step-through debugging

Step-through debugging is a more advanced debugging technique that involves executing your program one line at a time. With each step, you can observe the changes in your variables and the flow of your program. This is particularly useful for understanding complex control structures and pinpointing the exact location of a bug.

Debugging multithreaded C programs

Debugging multithreaded C programs is a bit more complicated due to the concurrent execution of multiple threads. However, modern IDEs and debuggers offer features such as thread-specific breakpoints and the ability to switch between threads. This allows you to isolate and debug each thread individually, making it easier to identify and fix concurrency-related bugs.

Steps to debug C programs 

Here is a general process you can follow to effectively debug C programs.

1. Understanding the problem

Before you can start debugging your C code, the first step is to understand the problem. Without a clear understanding of the issue, you risk wasting precious time and resources going down the wrong path. Start by examining the error messages you’re getting. These usually provide important clues about what’s going wrong.

Next, isolate the problem area in your code. Try running different sections of the code independently to identify where the issue lies. If you can pinpoint the section of the code that’s causing the error, you’ll be able to focus your debugging efforts more effectively.

2. Simple checks first

Once you’ve understood the problem, it’s time to start with some simple checks. This is an important step in C code debugging because it can save you a considerable amount of time. Start by checking for common errors like syntax errors, misspelled variables, wrong function calls, variable initializations, or incorrect data types.

Next, make sure that your code logic is correct. In some cases, the problem isn’t with the C syntax but with the logic of your program. Ensure that the conditions, loops, and function calls are working as expected.

3. Use print statements

By printing out the values of variables at different points in your program, you can track how they change and identify where things start to go wrong.

First, identify the critical variables in your code. These are variables that play a significant role in the operation of your program. Next, insert print statements to monitor the values of these variables as the program runs. This can help you spot unexpected changes or inconsistencies that might be causing issues.

4. Compile with debugging information

Another important step in C code debugging is compiling your code with debugging information. This involves using the -g option when compiling with the gcc compiler. This will include additional information in the executable file that can be used by a debugger to analyze your program.

Once you’ve compiled your program with debugging information, you can run it under a debugger. This will allow you to control the execution of the program, inspect the values of variables at any point, and even change them if necessary.

Remember, compiling with debugging information can make your executable file larger and slower to run. Therefore, it’s generally a good idea to do this only when you’re actively debugging your program.

5. Use a C code debugger

Using a C code debugger can take your debugging process to the next level. A debugger allows you to execute your program step by step, pause it at any point, inspect the values of variables, and even modify them.

There are several good debuggers available for C, including GDB, LLDB, and Microsoft’s Visual Studio Debugger. Each of these debuggers has its own set of features and commands, so you’ll need to spend some time learning how to use them effectively.

Remember, even with a good tool, effective debugging still requires a good understanding of your code and the problem you’re trying to solve.

6. Document the issue

By keeping a record of the problem and how you solved it, you can save yourself a lot of time and effort in the future, and can help others in your team or community who are facing the same issue.

Start by writing a clear, concise description of the problem. Include any error messages, the results of your initial investigation, and any theories you have about what’s causing the issue.

Next, document the steps you took to solve the problem. This should include any changes you made to your code, the results of your debugging sessions, and the final solution. It’s also a good idea to include any lessons learned or insights gained during the process.

This process can be time consuming, and often debugging tasks take up a large part of a developer’s valuable time. Today it’s possible to largely automate this process and debug your code with low effort, by leveraging generative AI technology.

Learn more in our detailed guide to Python Code Debugging.

Automating C code debugging with generative AI

Recent advances in generative AI can be a big help to development teams overloaded with debugging tasks. Tabnine is an AI code assistant that can predict and generate code completions in real time, and can provide automated debugging suggestions, which are sensitive to the context of your software project. Tabnine supports C and all other popular programming languages.

Tabnine: The AI code assistant that you control 

Tabnine is an AI code assistant that helps development teams of every size use AI to accelerate and simplify the software development process without sacrificing privacy, security, or compliance. Tabnine boosts engineering velocity, code quality, and developer happiness by automating the coding workflow through AI tools customized to your team. Tabnine supports more than one million developers across companies in every industry. 

Unlike generic coding assistants, Tabnine is the AI that you control:

It’s private. You choose where and how to deploy Tabnine (SaaS, VPC, or on-premises) to maximize control over your intellectual property. Rest easily knowing that Tabnine never stores or shares your company’s code.  

It’s personalized. Tabnine delivers an optimized experience for each development team. It’s context-aware and delivers precise and personalized recommendations for code generation, code explanations, guidance, and for test and documentation generation.

It’s protected. Tabnine is built with enterprise-grade security and compliance at its core. It’s trained exclusively on open source code with permissive licenses, ensuring that customers are never exposed to legal liability.

Tabnine provides accurate and personalized code completions for code snippets, whole lines, and full functions. Tabnine Chat in the IDE allows developers to communicate with a chat agent in natural language and get assistance with various coding tasks: 

• Generating new code 
• Generating unit tests 
• Getting the most relevant answer to your code
• Mentioning and referencing code from your workspace
• Explaining code
• Extending code with new functionality
• Refactoring code
• Documenting code
• Onboarding faster with the Onboarding Agent

Learn how to use Tabnine AI to analyze, create, and improve your code across every stage of development:

Try Tabnine for free today or contact us to learn how we can help accelerate your software development.