Debugging Techniques in C

Introduction

Ever felt like you’re playing a game of hide and seek with bugs in your C code? You’re not alone. Debugging is an essential part of programming, and mastering it can save you hours of headache. In this tutorial, we’ll explore various debugging techniques in C, providing you with the tools to squash those bugs efficiently and effectively.

Understanding Debugging

Before we dive in, let’s clarify what debugging is. Debugging is the process of identifying, isolating, and fixing errors or “bugs” in your program. It’s an integral part of the program life cycle, which includes design, implementation, testing, and debugging.

Debugging Techniques

Non-Interactive Debugging

Non-interactive debugging involves using print statements to display the values of variables at certain points in your program. This can be achieved in C using printf statements. For example:

#ifdef DEBUG_ENABLED
    printf("Variables Currently Contain: %d, %f, %s\n", i, *pf[1], str);
#endif

Complete executable program:

#include <stdio.h>

#define DEBUG_ENABLED

int main() {
    int i = 42;
    float f[] = {3.14, 2.71};
    float *pf[] = {&f[0], &f[1]};
    char str[] = "Hello, World!";

#ifdef DEBUG_ENABLED
    printf("Variables Currently Contain: %d, %f, %s\n", i, *pf[1], str);
#endif

    // Rest of your program logic

    return 0;
}
C

Using a Debugger: GNU gdb

GNU gdb is a powerful debugger for C. To use gdb, you first need to compile your code with the -g option and without any optimization (i.e., no -O2 flag). Once you’ve done that, you can run gdb <exe>, where <exe> is the name of your executable.

gcc -g -o myprogram myprogram.c
gdb myprogram

Assertions

Assertions are a way to catch bugs earlier by expressing conditions that should be true at certain points in your program. If an assertion fails, the program will terminate, allowing you to identify and fix the bug. Here’s an example:

#include <assert.h>
assert(0 <= i && i < 10);
assert(0 <= a[i] && a[i] < 10);
C

Complete executable program:

#include <stdio.h>
#include <assert.h>

int main() {
    int i = 5;
    int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    assert(0 <= i && i < 10);
    assert(0 <= a[i] && a[i] < 10);

    printf("Assertions passed!\n");

    // Rest of your program logic

    return 0;
}

Code Examples

Example 1: Using gdb

Let’s take a look at a simple example of how to use gdb. Suppose we have the following C program:

#include <stdio.h>

int main() {
    int i;
    int numTerms = 10;
    int t1 = 0, t2 = 1;
    int nextTerm;

    printf("Fibonacci Series: ");

    for (i = 1; i <= numTerms; ++i) {
        printf("%d, ", t1);
        nextTerm = t1 + t2;
        t1 = t2;
        t2 = nextTerm;
    }

    return 0;
}
C

We can debug this program using gdb as follows:

gcc -g -o fib fib.c
gdb fib

Inside gdb, we can set a breakpoint at line 12 (break 12), run the program (run), and then step through the loop (next) to watch the values of the variables change.

Example 2: Using Assertions

Consider the following function that calculates the density of ‘e’ characters in a word:

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

float find_e_density(const char *word) {
    int len, e_count = 0, i;

    assert(word != NULL); /* word should point to valid memory */
    len = strlen(word);
    assert(len != 0); /* word should not be 0-length for valid density */

    for (i = 0; word[i] != 0; ++i) {
        if (word[i] == 'e') {
            ++e_count;
        }
    }
    return e_count / (float)len; /* Above assertion protects against division by 0 */
}

int main() {
    const char *sample_word = "example";
    float density = find_e_density(sample_word);
    
    printf("The 'e' density in '%s' is: %.2f\n", sample_word, density);
    
    return 0;
}
C

In this example, we use assertions to ensure that the word pointer points to valid memory and that the word is not zero-length. These assertions help us catch bugs before they cause problems.

Wrapping Up

Debugging is a crucial skill for any programmer. By understanding and effectively using debugging techniques such as non-interactive debugging, using a debugger like gdb, and using assertions, you can save yourself time and frustration. Remember, the goal is not to write code that never has bugs (although that would be nice), but to be able to efficiently and effectively find and fix those bugs when they do inevitably occur.

Frequently Asked Questions (FAQ)

  1. What is debugging in C programming?

    Debugging in C programming is the process of identifying, isolating, and fixing errors or “bugs” in your C code.

  2. What are debugging techniques?

    Debugging techniques are methods used to identify and fix bugs in your code. They include non-interactive debugging, using a debugger like gdb, and using assertions.

  3. What are the 6 debugging techniques in an embedded system?

    The six debugging techniques commonly used in an embedded system are: simulation, firmware logging, in-circuit emulation, firmware toggling a line, firmware writing to a port, and using a logic analyzer.

  4. What are the 4 steps to debugging a code?

    The four steps to debugging code are: identifying the problem (where the code doesn’t produce the expected result), isolating the source of the problem (where in the code the error is occurring), correcting the problem (modifying the code to fix the error), and testing the correction (making sure the error has been correctly fixed).

  1. Understanding Syntax, Semantic, and Runtime Errors in C
  2. Understanding Variables and Data Types in C
  3. Efficient Memory Management in C

Remember, the key to becoming a great programmer isn’t avoiding mistakes, but learning how to fix them. Happy debugging!

Learn about various debugging techniques in C, including non-interactive debugging, using a debugger like gdb, and using assertions. This comprehensive guide provides practical examples and is perfect for anyone looking to improve their debugging skills in C.

Website |  + posts

Dr. Mehedi Hasan is a seasoned semiconductor professional, academic and web-designer with over a decade of experience in digital system design and verification as well as web development. Currently a Senior Engineer at AMD in Markham, Ontario, he plays a key role in the development and verification of cutting-edge chip technologies, earning multiple Spotlight Awards for his contributions.

Dr. Hasan holds a Ph.D. in Electrical and Computer Engineering from the University of Saskatchewan and has served in both academia and industry across Canada, Bangladesh, Malaysia, and Saudi Arabia. His expertise spans web-development, UVM-based SystemVerilog verification, static timing analysis (STA), RTL design, and scripting in multiple languages including Python, TCL, Shell as well as web-development tools including HTML, CSS, Javascript.

Passionate about knowledge sharing and education, Dr. Hasan has also worked as an Assistant Professor in Ontario, Canada (at Lakehead University) and Bangladesh University. He is committed to building accessible learning environments and is the founder of SkillSeminary, a platform focused on simplifying complex tech concepts for learners worldwide.

When he's not immersed in chip verification or educational projects, Dr. Hasan enjoys mentoring, researching system development, and promoting open tech education.

Scroll to Top