CSC 1029 Common Code Mistakes

CSC 1029 Common Code Mistakes

• Objectives: Identify common coding errors (off-by-one, incorrect data types, logic flaws, infinite loops). Explain causes and consequences of these errors in different programming contexts. Develop strategies for proactive avoidance, employing best practices during code development. Categorize errors (syntax, runtime, logical). Apply debugging techniques to identify and resolve coding errors.

Common Coding Mistakes

• Undeclared Variables: Variables not defined before use.
• Uninitialized Variables: Variables used without a value assigned.
• Mismatched Code Blocks: Incorrectly paired begin/end statements.
• Undeclared Functions: Functions called without being defined.
• Overstepping Array Boundaries: Accessing array elements outside their valid range.
• Misusing &&/|| Operators: Incorrect use of logical AND/OR operators.
• Using Single Equal Sign for Equality Check: Using = instead of == for comparisons.
• Input Errors: Not understanding delimiters or the differences between >> and getline when reading data.

Forgetting to Include Header Files

• Include necessary header files like iostream, string. Matching functions with correct header files. Example mappings: pow (), std::setprecision (), toupper/transform (), std::stoi ().

Syntax Errors

• Missing semicolons at the end of statements or incorrect placement can cause compilation errors.

Memory Management Errors & Pointers

• Memory management errors: Improper allocation/deallocation of memory using new, delete, malloc, free leading to memory leaks or access violations. Mishandling pointers (dereferencing null pointers, accessing out-of-bounds memory, failing to deallocate allocated memory).

Using Uninitialized Variables

• Not initializing variables before use results in unpredictable behavior and hard-to-trace bugs.

Misunderstanding Array Indexing

• C++ arrays are zero-indexed, meaning the first element is at index 0. Incorrect indexing leads to bugs.

Pass By Value and Pass By Reference

• Confusion between pass-by-value and pass-by-reference methods can lead to inefficiencies or unintended data modifications.

Mixing up = and ==

• Incorrect use of the assignment operator (=) and comparison operator (==) in conditional statements creates logical errors.

Ignoring Return Values

• Failure to check the return values of functions, especially those that may fail, leads to unexpected behavior or missed errors.

Not Using Const Correctly

• Incorrect use of the const keyword can cause accidental modifications to variables or objects intended to be constant.

Failure to Handle Errors

• Ignoring error handling will lead to program crashes or unexpected behavior during exceptional conditions.

Inefficient Algorithms

• Utilizing inefficient algorithms or data structures, especially when handling large datasets, impacts program performance.

Mixing C and C++

• Mixing C-style code with C++ features can introduce inconsistencies or bugs due to differences in the languages.

Not Understanding OOP

• Failure to grasp OOP concepts (inheritance, polymorphism, encapsulation) can negatively impact design decisions and lead to improper use of those features.

Outputting Information

• C++ uses std::cout for user output, std::cerr for error/diagnostic messages, and std::clog for logging. Log files offer permanent program information storage, aiding debugging and analysis.

std::cout

• A standard output stream, typically used to display output on the console.
• Buffered: Output might not appear immediately, held in a buffer.
• Redirection: Output can be redirected to a file using shell redirection operators (e.g., >).

std::cerr

• A standard error stream mainly used for error and diagnostic messages.
• Unbuffered: Error messages appear immediately on the console
• Redirection: Error output can be redirected as with cout.

std::clog

• A standard output stream for logging.
• Buffered: Output is buffered, similar to cout, may not appear immediately.
• Redirection: Output can be directed to a file.

Log Files

• Log files store program execution info, allowing for customized formats, content, and detail levels. Useful for debugging, analyzing program behavior, and tracking events.

To Do List

• Post weekly discussion question and research solution to D2L.
• Complete Week 08 content module in D2L to 100%.

Help/Support

• Student office hours (by appointment, drop-in).
• Email: [email protected]
• On-campus tutoring.
• 24/7 online tutoring. Consult D2L resources for help section.

This quiz focuses on identifying and understanding common coding errors that programmers encounter. It covers various mistakes such as undeclared variables, logic flaws, and misuse of operators, while also providing strategies to avoid these issues. Participants will learn to categorize errors and apply effective debugging techniques.