Department of Engineering Technology
Computer programming (CET-121)
Fall 2023
Lab 12
Objective:
Debugging Techniques in Programming
Student Information
Student Name
Student ID
Date
Assessment
Marks Obtained
Remarks
Signature
1
Lab 12: Debugging Techniques in Programming
Objective:
The main goal of this lab is to familiarize students with effective debugging techniques to identify
and correct errors and logic flaws in a program.
Importance of Debugging in the Software Development Process in C++:
Debugging is a crucial aspect of the software development process in C++ as it plays a pivotal role in
ensuring the reliability and correctness of a program. Even the most seasoned developers encounter
errors in their code, and effective debugging is essential for identifying and rectifying these issues.
Debugging not only helps in eliminating errors but also enhances the overall quality of the code,
making it more efficient and maintainable.
Common Types of Errors in C++:
1. Syntax Errors:
- Syntax errors occur when the code violates the rules of the C++ language. These errors are
typically detected by the compiler during the compilation phase. Examples include missing
semicolons, mismatched parentheses, or incorrect variable declarations.
2. Runtime Errors:
- Runtime errors occur during the execution of the program. They often lead to program crashes or
unexpected behavior. Examples include division by zero, accessing an out-of-bounds array element,
or dereferencing a null pointer.
3. Logic Errors:
- Logic errors are more subtle and challenging to detect. They occur when the program's logic is
flawed, leading to incorrect results. Examples include incorrect algorithm implementation, flawed
conditional statements, or improper loop control.
2
Key Debugging Tools in C++:
1. Print Statements:
- The use of print statements (e.g., `cout` statements) is a simple yet effective way to trace the flow
of the program and inspect variable values during runtime.
cout << "Debugging point A" << endl;
// Print variable values
cout << "Variable x: " << x << endl;
2. Debugging Environments (e.g., GDB):
- Debugging environments, such as GDB (GNU Debugger), provide advanced debugging features.
These include setting breakpoints, stepping through code, and inspecting variable values interactively.
gdb ./your_program
(gdb) break main
(gdb) run
3. Version Control Systems (e.g., Git):
- Version control systems like Git allow developers to track changes in their code base. This is
valuable for identifying when errors were introduced and for collaborating with other developers.
git commit -m "Fixed bug in function foo"
Common Debugging Techniques in C++:
a. Print Statements:
Using print statements, such as `cout` in C++, is a fundamental and straightforward method to
understand the flow of the program and inspect the values of variables at different points during
runtime.
Example:
#include <iostream>
Using namespace std;
3
int main() {
int x = 5;
cout << "Debugging point A" << endl;
// Print variable values
cout << "Variable x: " << x << endl;
// Your code logic
cout << "Debugging point B" << endl;
return 0;
Exercise:
Given a C++ program with logical errors, use print statements strategically to identify and correct
the issues.
#include <iostream>
Using namespace std;
int main() {
// Logical error 1: Incorrect variable initialization
int x = 5;
int y = 0;
// Logical error 2: Incorrect loop condition
for (int i = 0; i <= 5; ++i) {
// Logical error 3: Incorrect calculation
y = x * i;
// Print statements to debug
cout << "i: " << i << endl;
4
cout << "x: " << x << endl;
cout << "y: " << y << endl;
// Logical error 4: Incorrect output
cout << "Result: " << x + y << endl; }
// Logical error 5: Incorrect return statement
return 0;}
In this example:
1. Added print statements to display the values of variables (`i`, `x`, `y`) at different points in the
program.
2. Corrected the initialization of variables `x` and `y`.
3. Adjusted the loop condition to make it more suitable.
4. Corrected the calculation of the variable `y`.
5. Fixed the output statement to display the correct result.
6. Corrected the return statement.
By strategically placing print statements and analyzing the output, you can identify and correct logical
errors in your C++ program. Keep in mind that this is a simplified example, and in a real-world
scenario, you may encounter more complex issues that require a more in-depth debugging approach,
possibly using a debugger or more sophisticated logging techniques.
b. IDE Debugging Tools:
Integrated Development Environments (IDEs) provide powerful debugging tools that assist in
identifying and fixing errors more efficiently. Key features include setting breakpoints, stepping
through code, and inspecting variable values in real-time.
Example:
Using breakpoints in an IDE like Visual Studio Code:
1. Set a breakpoint by clicking in the gutter next to the line number.
5
2. Start debugging the program.
3. Execution will pause at the breakpoint, allowing you to inspect variable values.
Exercise: Debug a C++ program using breakpoints and step-by-step execution in your
preferred IDE.
#include <iostream>
Using namespace std;
int main() {
int x = 5;
int y = 0;
for (int i = 1; i <= 5; ++i) {
y = x * i;
cout << "i: " << i << endl;
cout << "x: " << x << endl;
cout << "y: " << y << endl;
cout << "Result: " << x + y << endl; }
return 0;}
To debug a C++ program using breakpoints and step-by-step execution in Dev C++, follow these
steps:
1. Open the Project:
- Open Dev C++.
- Open your C++ project.
2. Set a Breakpoint:
- Locate the line where you want to start debugging.
- Click on the left margin of the editor window at that line number. This sets a breakpoint.
3. Compile the Program with Debug Information:
- Ensure that you are compiling your program with debugging information. In Dev C++, this is
6
typically done by selecting a "Debug" build or ensuring that debugging information is included in
your compilation settings.
4. Start Debugging:
- Go to the "Run" menu and select "Start Debugging" or press F5.
5. Execution Pauses at Breakpoint:
- The program will start, and execution will pause at the line where you set the breakpoint.
6. Inspect Variables:
- You can now inspect the values of variables by hovering over them or by using the Watches
window.
7. Step through the Code:
- Use the debugging toolbar or the keyboard shortcuts to step through the code:
- Step Into (F7): Executes the current line and moves to the next line. If the current line is a
function call, it enters the function.
- Step Over (F8): Executes the current line. If the current line is a function call, it executes the
entire function and moves to the next line in the calling function.
- Step Out (Shift + F8): Executes the remaining lines of the current function and returns to the
calling function.
8. Continue Execution:
- If you want to run the program until the next breakpoint, select "Continue" from the debugging
toolbar or press F9.
9. Inspecting Call Stack:
- The call stack window shows you the current function calls. You can use this to trace the flow of
your program.
10. Watch Window:
- Use the Watch window to monitor the values of specific variables during execution.
7
11. Fix Issues:
- As you step through the code, you may identify the issues causing unexpected behavior. Fix them
and continue debugging until your program runs correctly.
12. Stop Debugging:
- Once you've fixed the issues, stop debugging by selecting "Stop Debugging" from the "Run"
menu or by pressing Shift + F5.
c. Logging:
Logging involves strategically placing log statements in the code to capture information about the
program's behavior during runtime. This can help track the flow of execution and identify unexpected
behavior.
Example:
#include <iostream>
#include <fstream>
void logMessage(const string& message) {
ofstream logFile("logfile.txt", ios::app);
logFile << message << endl;
logFile.close();}
int main() {
logMessage("Program started");
// Your code logic
logMessage("Debugging point reached");
return 0;}
Exercise: Implement logging in a C++ program and analyze the log output to identify and
fix issues.
#include <iostream>
8
#include <fstream>
Using namespace std;
// Logging function
void logMessage(const string& message) {
// Open the log file in append mode
ofstream logfile("logfile.txt", ios::app);
// Write the message to the log file
logfile << message << endl;
// Close the log file
logfile.close();}
int main() {
// Initialize variables
int x = 5;
int y = 0;
// Attempt to perform a division
logMessage("Attempting division...");
// Check for division by zero
if (y != 0) {
int result = x / y;
logMessage("Result: " + to_string(result));
} else {
logMessage("Error: Division by zero!"); }
return 0;}
9
Follow the steps below to compile and run this program in Dev C++:
1. **Open Dev C++:**
- Open Dev C++ and load your C++ project.
2. **Compile the Program:**
- Ensure that you are compiling the program with debugging information enabled.
3. **Run the Program:**
- Run the program from the Dev C++ environment.
4. **Check the Log File:**
- Open the `logfile.txt` and check for log messages.
The log file might look like this:
Attempting division...
Error: Division by zero!
By following these steps, you can implement logging in a C++ program using Dev C++, allowing
you to analyze log output to identify and fix issues.
Task:
Complete the following table:
Error Program Error Type Identify Error Debugging Corrected Program
technique
#include <iostream>
int main() {
cout << "Hello,
world!" << endl
return 0;}
#include <iostream>
int main() {
int x = 5;
int y = 0;
int result = x / y; //
Division by zero
cout << "Result: "
<< result << endl;
return 0;}
10
#include <iostream>
int main() {
int x = 5;
int y = 3;
int result = x * y; //
Incorrect
multiplication
cout << "Result: "
<< result << endl;
return 0;}
11
