Common Errors in Programming

• Learn from your mistakes!! When you discover the reason for a bug, make a note of it in a log book, write down what you did, why you think you made the mistake, what you did to fix the bug. Look through this log once in a while, just to remind yourself. When you have a new bug that you can't seem to understand, look at your log - is this bug like any of the others you've seen? Try not to make the same mistake twice:)!
• An ounce of prevention is worth a pound of debugging. Think first, design correctly to start with and debugging is much less needed.
• Errors like division by zero occur as a program runs, so they call them run-time errors or execution time errors. Generally they are fatal, makes the program terminate immediately without finishing its job. Non-fatal errors are when a program completes its execution, often with incorrect results.
• Omitting the semicolon at the end of a statement is a syntax error. The computer issues an error message when it cannot recognize the statement. These messages can occur at the point of the error, or after it. Don't assume the error message is a correct description of the mistake in the program; a compiler is not too smart. It does not know what you meant to say.
• Using the modulus operator, %, with non-integer operands is a syntax error.
• Confusing the == operator with the = operator will not necessarily cause a syntax error, but it is almost always a logical error to use one when you mean to use the other.
• Reversing the symbols in "<=" (or "!=" or ">=" or "==") or putting spaces between them is a syntax error.
• Putting too many semicolons in a program can cause errors. Putting one immediately after the closing parenthesis of an if condition makes the if statement have an empty body. This is most often a logic error.

  if (a == b);
  	cout << "yes";
  

  will always output "yes'.
• In an If statement, remember to use a pair of braces ({}) if the then-clause or else-clause is a sequence of statements. And be sure not to put a semicolon after the right brace.

• Using a keyword as an identifier is a syntax error.

        main = 25;
  

• Unbalanced braces ({}) will cause a syntax error that the compiler will catch. Completely missing or misplaced braces will probably not be detected by the compiler but can cause many different logical errors.
• If you are writing a loop, remember to provide some action that eventually causes the condition of the loop to become false. Otherwise you get an "infinite loop" which is usually an error.
• Remember that keywords are all lower case. "While" is not the same as "while".
• If a counter or accumulator is not initialized, the results of your program are unpredictable.
• Remember that floating point numbers should not be compared for exact equality. They are represented only approximately in most computers.
• If you declare the counter control variable for a for loop in the head of the loop, don't use the variable after the body of the loop.
• Although 3 < x < 7 is mathematically correct, it does not evaluate correctly in C++. You should use 3 < x && x < 7 to get the proper evaluation.
• An int constant value should not start with a 0 unless it is 0. A number that starts with a zero is considered an octal (base 8) number. For example, 010 is considered octal 10 which is decimal 8.
• If the cause of an error in a program is not obvious, leave the computer and study a printed listing. Change your program only after you understand the source of the error.
• Avoid mixing integer and double values in expressions. If you must mix them, consider using explicity type casts to reduce the chance of mistakes.
• For each assignment statement, check that the expression on the right hand side results in the same data type as the variable on the left hand side. If not, consider an explicit type cast for clarity and safety. And remember that storing a floating point value into an int variable truncates the fractional part.
• If your program reads data from an input file, it should verify that the file has opened successfully.

• Take some sample values and try them by hand in your program. That way you have something to check against your program's output.
• If your program produces an answer that does not agree with a value that you've calculated by hand, try these:
  • Redo your arithmetic
  • Recheck your input data
  • Go over the section of code that does the calculations. If you're in doubt about the order in which the operations are performed, insert clarifying parentheses.
  • Check for integer overflow. The value of an int variable may have exceeded INT_MAX in the middle of a calculation. Some systems give a message when this happens, most do not.
  • Check the conditions in branching statements to be sure that the correct branch is executed in all circumstances. Check the conditions in looping statements to be sure that the loop body is executed the correct number of times.
  • If your code contains a loop, check the loop termination condition carefully and make sure that something in the loop causes it to be met. Trace the execution of the loop by hand. Simulate the first few passes and the last few passes very carefully to see how the loop really behaves.
  • Use a debugger if your system has one. It lets you run your program in "slow motion", executing one instruction at a time and examining the contents of variables as they change.
  • If all else fails, use debug output statements - output statements inserted into a program to help debug it. They output messages that indicate the flow of execution in the program and show values for variables at certain points in the program. After you have debugged your program, you can remove the debug output statements, or comment them out.
  • Use debug output statements to indicate when a function is called and if it is executing correctly. The values in teh arguments can be printed immediately before the call (to show the incoming values) and immediately after the call (to show the outgoing values). You can use debug output statements in the function itself to indicate what happens each time the function is called.

• Plan your test data carefully to test all sections of a program.
• Beware of infinite loops. The symptom: the program doesn't stop. If you have created an infinite loop, check your logic and the syntax of your loops. Be sure there's no semicolon immediately after the right parenthesis of the while condition

  	while (expression);
  		body;
  

  This usually causes an infinite loop.
• In a counter-controlled loop, make sure the loop control variable is changed inside the loop. In a flag-controlled loop, make sure the flag eventually changes.
• Watch out for = versus ==.

  	while (someVar = 5) // wrong!
  	 {   body ; }
  

  is an infinite loop. The assignment in the condition evaluates to 5, which is not zero, so the computer interprets it as True.