GDB (GNU Debugger)
GDB is the most widely used command-line debugger for C++ in Linux. It allows developers to control program execution (start/stop), inspect variables, view call stacks, and navigate source code. Key features include setting breakpoints (line/function), single-stepping (into/out of functions), modifying variables, and analyzing crash dumps. Compilation with -g (to include debug symbols) is required for effective debugging. GDB supports advanced features like conditional breakpoints, watchpoints (track variable changes), reverse debugging, and remote debugging for embedded systems.
LLDB
LLDB is a modern debugger from the LLVM project, designed to replace GDB in many workflows. It offers a more intuitive command structure (e.g., breakpoint set instead of break) and better integration with Clang/LLVM. Core features include stepping through code, inspecting variables, setting breakpoints, and viewing disassembled code. LLDB is the default debugger in Xcode (macOS) but is fully supported on Linux, making it a viable alternative to GDB for C++ development.
Valgrind
Valgrind is a suite of tools for detecting memory-related issues (leaks, invalid access, uninitialized values). The most commonly used tool is Memcheck, which tracks memory allocations/deallocations to identify leaks and improper usage. Other tools include Helgrind (threading errors) and Cachegrind (performance profiling). Valgrind is run separately from the debugger (e.g., valgrind --leak-check=full ./program) and provides detailed reports to help fix memory bugs.
AddressSanitizer (ASan)
ASan is a fast memory error detector integrated into GCC and Clang. It detects buffer overflows (stack/heap), use-after-free, double-free, and uninitialized memory access. Unlike Valgrind, ASan runs alongside the program with minimal overhead (2-3x slowdown). To use ASan, compile with -fsanitize=address and link with -fsanitize=address; runtime errors are reported with stack traces to pinpoint the source.
ThreadSanitizer (TSan)
TSan is a tool for detecting data races in multithreaded C++ programs. It identifies unsynchronized access to shared data (e.g., two threads writing to the same variable without locks). Compilation requires -fsanitize=thread, and TSan reports races with detailed stack traces to help fix concurrency issues. It is particularly useful for debugging complex multithreaded applications.
Visual Studio Code (VS Code) with C/C++ Extension
VS Code is a lightweight, extensible editor that supports C++ debugging via the C/C++ Extension. Developers can configure a launch.json file to define debugging settings (e.g., program path, arguments, breakpoints) and use a graphical interface to step through code, inspect variables, and view call stacks. VS Code integrates with GDB/LLDB, offering a hybrid experience between command-line power and visual convenience.
CLion
CLion is a commercial IDE from JetBrains specifically designed for C++ development. It includes a built-in debugger that supports both GDB and LLDB, providing a rich graphical interface for debugging. Features include breakpoints, variable inspection, call stack analysis, and expression evaluation. CLion also offers refactoring tools, code analysis, and integration with version control, making it a comprehensive solution for C++ projects.
DDD (Data Display Debugger)
DDD is a graphical front-end for command-line debuggers like GDB. It provides a visual interface to display source code, variables, and call stacks, making it easier for beginners to understand program flow. DDD supports features like breakpoints, single-stepping, and variable modification, while leveraging the underlying power of GDB for advanced debugging tasks.