debugging

---

1. Using assert() Macro:

assert(x > 0);  // Check if x is greater than 0, else terminate with an assertion error message

2. Using std::exception:

try {
    // Code that may throw an exception
} catch (const std::exception& e) {
    std::cerr << "Exception: " << e.what() << std::endl;
}

3. Using std::cerr for Printing Error Messages:

std::cerr << "Error: " << errorMessage << std::endl;

4. Using std::cout for Printing Debug Information:

std::cout << "Debug: " << debugMessage << std::endl;

5. Using std::ofstream for Logging Debug Information:

std::ofstream logFile("debug.log");
logFile << "Debug: " << debugMessage << std::endl;

6. Using GDB (GNU Debugger):

// Set breakpoints at specific lines using `gdb --args ./a.out`
(gdb) break 15

7. Using LLDB (Low Level Debugger):

// Set breakpoints at specific lines using `lldb`
(lldb) break set -f sourcefile.cpp -l 15

8. Using Visual Studio Debugger:

// Set breakpoints in Visual Studio by right-clicking in the code editor and selecting "Breakpoint"

9. Using valgrind for Memory Debugging:

// Check for memory leaks and other memory errors using `valgrind --leak-check=full ./a.out`

10. Using asan (Address Sanitizer):

// Check for memory errors using `gcc -fsanitize=address ./a.out`

11. Using msan (Memory Sanitizer):

// Check for memory errors using `gcc -fsanitize=memory ./a.out`

12. Using ubsan (Undefined Behavior Sanitizer):

// Check for undefined behavior using `gcc -fsanitize=undefined ./a.out`

13. Using tsan (Thread Sanitizer):

// Check for thread safety violations using `gcc -fsanitize=thread ./a.out`

14. Using drd (Data Race Detector):

// Check for data races using `gcc -fdrd ./a.out`

15. Using gdb with bt Command for Backtrace:

(gdb) bt  // Print a backtrace of the function call stack

16. Using gdb with p Command for Printing Variables:

(gdb) p x  // Print the value of variable x

17. Using gdb with watch Command for Watching Variables:

(gdb) watch x  // Set a watchpoint on variable x

18. Using gdb with disassemble Command for Disassembling Instructions:

(gdb) disassemble main  // Disassemble the main function

19. Using gdb with stepi Command for Stepping into Functions:

(gdb) stepi  // Step into the next function call

20. Using gdb with nexti Command for Stepping over Function Calls:

(gdb) nexti  // Step over the next function call

21. Using gdb with finish Command for Running until Function Returns:

(gdb) finish  // Run until the current function returns

22. Using gdb with continue Command for Continuing Execution:

(gdb) continue  // Continue execution after hitting a breakpoint

23. Using gdb with list Command for Listing Source Code:

(gdb) list  // List source code around the current line

24. Using gdb with info Command for Getting Information:

(gdb) info breakpoints  // List all breakpoints

25. Using gdb with r Command for Running the Program:

(gdb) r  // Run the program from the beginning

26. Using gdb with b Command for Setting Breakpoints:

(gdb) b main  // Set a breakpoint at the start of the main function

27. Using gdb with tbreak Command for Setting Temporary Breakpoints:

(gdb) tbreak main  // Set a temporary breakpoint at the start of the main function

28. Using gdb with n Command for Stepping to the Next Statement:

(gdb) n  // Step to the next statement

29. Using gdb with s Command for Stepping into Functions:

(gdb) s  // Step into the next function

30. Using gdb with until Command for Stepping until a Given Line:

(gdb) until 100  // Step until line 100 is reached

31. Using gdb with watch Command for Watching Variables:

(gdb) watch x  // Watch the value of variable x

32. Using gdb with print Command for Printing Values:

(gdb) print x  // Print the value of variable x

33. Using gdb with display Command for Displaying Values:

(gdb) display x  // Display the value of variable x every time it changes

34. Using gdb with set Command for Setting Variables:

(gdb) set x = 10  // Set the value of variable x to 10

35. Using gdb with x Command for Examining Memory:

(gdb) x/10x &x  // Examine 10 words of memory starting at the address of variable x

36. Using gdb with bt Command for Backtracing the Call Stack:

(gdb) bt  // Print a backtrace of the call stack

37. Using gdb with info Command for Getting Information:

(gdb) info locals  // Print the values of local variables

38. Using gdb with source Command for Reading Source Code:

(gdb) source main.c  // Read the source code of the main.c file

39. Using gdb with help Command for Getting Help:

(gdb) help bt  // Get help on the bt command

40. Using gdb with quit Command for Quitting the Debugger:

(gdb) quit  // Quit the gdb debugger

41. Using printf() for Simple Debugging:

printf("Debug: x = %d\n", x);  // Print the value of variable x for debugging purposes

42. Using cout for Debugging in C++:

std::cout << "Debug: x = " << x << std::endl;  // Print the value of variable x for debugging purposes

43. Using cerr for Error Handling:

std::cerr << "Error: " << errorMessage << std::endl;  // Print an error message to the standard error stream

44. Using assert() for Assertions:

assert(x > 0);  // Check if x is greater than 0, otherwise terminate the program with an assertion error

45. Using throw for Throwing Exceptions:

throw std::runtime_error("Error: Invalid argument");  // Throw an exception with an error message

46. Using try-catch for Catching Exceptions:

try {
    // Code that may throw an exception
} catch (const std::exception& e) {
    std::cerr << "Error: " << e.what() << std::endl;  // Handle the exception
}

47. Using debugger Keyword for Entering Debugger:

debugger;  // Enter the debugger at runtime

48. Using _CrtSetBreakAlloc() for Detecting Memory Leaks:

_CrtSetBreakAlloc(123);  // Set a breakpoint on the 123rd memory allocation

49. Using _CrtDumpMemoryLeaks() for Dumping Memory Leaks:

_CrtDumpMemoryLeaks();  // Dump any memory leaks in the program

50. Using a Custom Debugger:

class Debugger {
public:
    void log(const std::string& message) {
        std::cerr << "Debug: " << message << std::endl;
    }
};

Debugger debugger;  // Create a debugger object
debugger.log("x = " + std::to_string(x));  // Log the value of variable x for debugging purposes