Coming Soon

Common semantic errors in C++

In this lesson, you'll learn about semantic errors - bugs that don't prevent your program from compiling but cause it to behave incorrectly at runtime.

What are semantic errors?

Semantic errors are logical mistakes in your code that compile successfully but produce incorrect results. Unlike syntax errors (which prevent compilation), semantic errors create programs that run but don't do what you intended.

Think of semantic errors like giving someone directions to your house, but accidentally telling them to turn left instead of right. The directions are grammatically correct, but they won't get the person to the right place.

Types of semantic errors

Logic errors

The program follows a flawed algorithm or incorrect reasoning:

#include <iostream>

// Bug: Incorrect logic for checking if a number is even
bool isEven(int num)
{
    return num % 2 == 1;  // Should be == 0
}

int main()
{
    std::cout << "Is 4 even? " << isEven(4) << std::endl;  // Prints 0 (false)
    std::cout << "Is 5 even? " << isEven(5) << std::endl;  // Prints 1 (true)

    // The logic is backwards!
    return 0;
}

Output:

Is 4 even? 0
Is 5 even? 1

Correct version:

bool isEven(int num)
{
    return num % 2 == 0;  // Fixed: even numbers have remainder 0
}

Off-by-one errors

Very common errors involving loop boundaries or array indices:

#include <iostream>

void printNumbers1to10()
{
    std::cout << "Numbers 1 to 10:" << std::endl;

    // Bug: Loop stops at 9 instead of 10
    for (int i = 1; i < 10; ++i)  // Should be i <= 10
    {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

void printArrayElements()
{
    int numbers[] = {10, 20, 30, 40, 50};
    int size = 5;

    std::cout << "Array elements:" << std::endl;

    // Bug: Accesses one past the end of array
    for (int i = 0; i <= size; ++i)  // Should be i < size
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
}

int main()
{
    printNumbers1to10();
    std::cout << std::endl;
    printArrayElements();

    return 0;
}

Output:

Numbers 1 to 10:
1 2 3 4 5 6 7 8 9

Array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50
numbers[5] = 0  // Undefined behavior - accessing invalid memory

Fixed version:

void printNumbers1to10Fixed()
{
    for (int i = 1; i <= 10; ++i)  // Fixed: include 10
    {
        std::cout << i << " ";
    }
}

void printArrayElementsFixed()
{
    int numbers[] = {10, 20, 30, 40, 50};
    int size = 5;

    for (int i = 0; i < size; ++i)  // Fixed: stop before size
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }
}

Infinite loops

Loops that never terminate because their condition is never met:

#include <iostream>

void demonstrateInfiniteLoops()
{
    std::cout << "Example 1: Counter going wrong direction" << std::endl;

    // Bug: Counting down when we should count up
    /*
    int count = 0;
    while (count < 5)
    {
        std::cout << count << " ";
        count--;  // Bug: Should be count++
    }
    */

    // This would run forever: 0, -1, -2, -3, ... (always < 5)
    std::cout << "Infinite loop prevented!" << std::endl;

    std::cout << "\nExample 2: Condition never changes" << std::endl;

    /*
    int x = 10;
    while (x > 5)
    {
        std::cout << "x is " << x << std::endl;
        // Bug: x never changes, so x > 5 is always true
    }
    */

    std::cout << "Another infinite loop prevented!" << std::endl;
}

void fixedLoops()
{
    std::cout << "Fixed version 1:" << std::endl;
    int count = 0;
    while (count < 5)
    {
        std::cout << count << " ";
        count++;  // Fixed: increment instead of decrement
    }
    std::cout << std::endl;

    std::cout << "Fixed version 2:" << std::endl;
    int x = 10;
    while (x > 5)
    {
        std::cout << "x is " << x << std::endl;
        x--;  // Fixed: modify the loop variable
    }
}

int main()
{
    demonstrateInfiniteLoops();
    std::cout << std::endl;
    fixedLoops();

    return 0;
}

Output:

Example 1: Counter going wrong direction
Infinite loop prevented!

Example 2: Condition never changes
Another infinite loop prevented!

Fixed version 1:
0 1 2 3 4

Fixed version 2:
x is 10
x is 9
x is 8
x is 7
x is 6

Variable initialization errors

Using variables before giving them a value:

#include <iostream>

void uninitializedVariables()
{
    int sum;        // Bug: Not initialized
    int count = 0;  // Correctly initialized

    // Bug: Using sum before assigning a value
    for (int i = 1; i <= 5; ++i)
    {
        sum += i;   // sum starts with garbage value
        count++;
    }

    std::cout << "Sum: " << sum << std::endl;      // Unpredictable result
    std::cout << "Count: " << count << std::endl;  // Predictable result: 5
}

void fixedInitialization()
{
    int sum = 0;    // Fixed: Initialize to 0
    int count = 0;

    for (int i = 1; i <= 5; ++i)
    {
        sum += i;
        count++;
    }

    std::cout << "Sum: " << sum << std::endl;      // Correct result: 15
    std::cout << "Count: " << count << std::endl;  // Correct result: 5
}

int main()
{
    std::cout << "With uninitialized variable:" << std::endl;
    uninitializedVariables();

    std::cout << "\nWith proper initialization:" << std::endl;
    fixedInitialization();

    return 0;
}

Possible Output: (results may vary due to undefined behavior)

With uninitialized variable:
Sum: 32782  // Unpredictable garbage value + 15
Count: 5

With proper initialization:
Sum: 15
Count: 5

Assignment vs. comparison errors

Accidentally using assignment (=) instead of comparison (==):

#include <iostream>

void assignmentVsComparison()
{
    int score = 85;

    // Bug: Assignment instead of comparison
    if (score = 100)  // This assigns 100 to score, doesn't compare!
    {
        std::cout << "Perfect score!" << std::endl;
    }

    std::cout << "Score after if statement: " << score << std::endl;

    // The condition always evaluates to true (non-zero value)
    // and score is now changed to 100
}

void fixedComparison()
{
    int score = 85;

    // Fixed: Use == for comparison
    if (score == 100)
    {
        std::cout << "Perfect score!" << std::endl;
    }
    else
    {
        std::cout << "Score is not perfect." << std::endl;
    }

    std::cout << "Score after if statement: " << score << std::endl;
}

int main()
{
    std::cout << "With assignment bug:" << std::endl;
    assignmentVsComparison();

    std::cout << "\nWith correct comparison:" << std::endl;
    fixedComparison();

    return 0;
}

Output:

With assignment bug:
Perfect score!
Score after if statement: 100

With correct comparison:
Score is not perfect.
Score after if statement: 85

Wrong operator precedence

Misunderstanding the order in which operations are performed:

#include <iostream>

void precedenceErrors()
{
    int a = 2;
    int b = 3;
    int c = 4;

    // Bug: Intended to calculate (a + b) * c, but + has lower precedence than *
    int result1 = a + b * c;
    std::cout << "a + b * c = " << result1 << " (expected 20, got " << result1 << ")" << std::endl;

    // Bug: Intended to check if (a + b) > c, but + has higher precedence than >
    bool result2 = a + b > c;
    std::cout << "a + b > c = " << result2 << " (this one is actually correct)" << std::endl;

    // Bug: Bitwise operations have unexpected precedence
    int x = 5;
    int y = 3;
    bool result3 = x & y == 0;  // Parsed as x & (y == 0), not (x & y) == 0
    std::cout << "x & y == 0 = " << result3 << " (probably not what was intended)" << std::endl;
}

void fixedPrecedence()
{
    int a = 2;
    int b = 3;
    int c = 4;

    // Fixed: Use parentheses to make intention clear
    int result1 = (a + b) * c;
    std::cout << "(a + b) * c = " << result1 << std::endl;

    // This was already correct, but parentheses make it clearer
    bool result2 = (a + b) > c;
    std::cout << "(a + b) > c = " << result2 << std::endl;

    // Fixed: Use parentheses for bitwise operations
    int x = 5;
    int y = 3;
    bool result3 = (x & y) == 0;
    std::cout << "(x & y) == 0 = " << result3 << std::endl;
}

int main()
{
    std::cout << "With precedence errors:" << std::endl;
    precedenceErrors();

    std::cout << "\nWith fixed precedence:" << std::endl;
    fixedPrecedence();

    return 0;
}

Output:

With precedence errors:
a + b * c = 14 (expected 20, got 14)
a + b > c = 1 (this one is actually correct)
x & y == 0 = 0 (probably not what was intended)

With fixed precedence:
(a + b) * c = 20
(a + b) > c = 1
(x & y) == 0 = 0

Array bounds errors

Accessing array elements outside the valid range:

#include <iostream>

void arrayBoundsErrors()
{
    int numbers[5] = {10, 20, 30, 40, 50};

    std::cout << "Valid array access:" << std::endl;
    for (int i = 0; i < 5; ++i)
    {
        std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
    }

    std::cout << "\nBug: Accessing out of bounds:" << std::endl;

    // Bug: Negative index
    std::cout << "numbers[-1] = " << numbers[-1] << " (undefined behavior)" << std::endl;

    // Bug: Index too large
    std::cout << "numbers[5] = " << numbers[5] << " (undefined behavior)" << std::endl;
    std::cout << "numbers[10] = " << numbers[10] << " (undefined behavior)" << std::endl;
}

void safeArrayAccess()
{
    int numbers[5] = {10, 20, 30, 40, 50};
    int size = 5;

    std::cout << "Safe array access with bounds checking:" << std::endl;

    auto safeGet = [&](int index) -> int {
        if (index < 0 || index >= size)
        {
            std::cout << "Error: Index " << index << " is out of bounds!" << std::endl;
            return -1;  // Error value
        }
        return numbers[index];
    };

    std::cout << "safeGet(-1) = " << safeGet(-1) << std::endl;
    std::cout << "safeGet(2) = " << safeGet(2) << std::endl;
    std::cout << "safeGet(5) = " << safeGet(5) << std::endl;
}

int main()
{
    arrayBoundsErrors();
    std::cout << std::endl;
    safeArrayAccess();

    return 0;
}

Possible Output: (undefined behavior may produce different results)

Valid array access:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Bug: Accessing out of bounds:
numbers[-1] = 4199040 (undefined behavior)
numbers[5] = 0 (undefined behavior)
numbers[10] = 1606416384 (undefined behavior)

Safe array access with bounds checking:
Error: Index -1 is out of bounds!
safeGet(-1) = -1
safeGet(2) = 30
Error: Index 5 is out of bounds!
safeGet(5) = -1

Function parameter errors

Passing wrong types or number of arguments:

#include <iostream>

double calculateAverage(int total, int count)
{
    return static_cast<double>(total) / count;
}

double calculateInterest(double principal, double rate, int years)
{
    return principal * rate * years;
}

void parameterErrors()
{
    // Bug: Parameters in wrong order
    double avg1 = calculateAverage(3, 150);  // Should be (150, 3)
    std::cout << "Average of 150/3: " << avg1 << " (wrong: passed count first)" << std::endl;

    // Correct order
    double avg2 = calculateAverage(150, 3);
    std::cout << "Average of 150/3: " << avg2 << " (correct)" << std::endl;

    // Bug: Wrong units/scale for parameters
    double interest1 = calculateInterest(1000.0, 5.0, 2);  // Rate as 5% but function expects 0.05
    std::cout << "Interest (5% rate as 5.0): " << interest1 << std::endl;

    // Correct usage
    double interest2 = calculateInterest(1000.0, 0.05, 2);  // Rate as decimal
    std::cout << "Interest (5% rate as 0.05): " << interest2 << std::endl;
}

int main()
{
    parameterErrors();
    return 0;
}

Output:

Average of 150/3: 50 (wrong: passed count first)
Average of 150/3: 50 (correct)
Interest (5% rate as 5.0): 10000
Interest (5% rate as 0.05): 100

Integer division errors

Expecting decimal results from integer division:

#include <iostream>

void integerDivisionErrors()
{
    int a = 7;
    int b = 2;

    // Bug: Integer division truncates decimal part
    double result1 = a / b;  // 7/2 = 3 (not 3.5)
    std::cout << "7 / 2 with integer division: " << result1 << std::endl;

    // Fixed: Cast to double before division
    double result2 = static_cast<double>(a) / b;
    std::cout << "7 / 2 with proper division: " << result2 << std::endl;

    // Another common mistake
    int total = 15;
    int count = 4;

    // Bug: Both integers, so result is truncated
    double average1 = total / count;
    std::cout << "Average (wrong): " << average1 << std::endl;

    // Fixed: Convert to double for accurate division
    double average2 = static_cast<double>(total) / count;
    std::cout << "Average (correct): " << average2 << std::endl;
}

void percentageCalculationError()
{
    int correct = 17;
    int total = 20;

    // Bug: Integer division gives 0, then multiplying by 100 still gives 0
    int percentage1 = (correct / total) * 100;
    std::cout << "Percentage (wrong method): " << percentage1 << "%" << std::endl;

    // Fixed: Do multiplication before division to avoid truncation
    int percentage2 = (correct * 100) / total;
    std::cout << "Percentage (integer method): " << percentage2 << "%" << std::endl;

    // Best: Use floating-point arithmetic
    double percentage3 = (static_cast<double>(correct) / total) * 100;
    std::cout << "Percentage (floating-point): " << percentage3 << "%" << std::endl;
}

int main()
{
    integerDivisionErrors();
    std::cout << std::endl;
    percentageCalculationError();

    return 0;
}

Output:

7 / 2 with integer division: 3
7 / 2 with proper division: 3.5

Average (wrong): 3
Average (correct): 3.75

Percentage (wrong method): 0%
Percentage (integer method): 85%
Percentage (floating-point): 85%

Scope and variable lifetime errors

Using variables outside their intended scope:

#include <iostream>

void scopeErrors()
{
    // Example 1: Variable only exists in loop scope
    for (int i = 0; i < 3; ++i)
    {
        int loopVar = i * 10;
        std::cout << "In loop: " << loopVar << std::endl;
    }

    // Bug: loopVar and i are out of scope here
    // std::cout << "After loop: " << loopVar << std::endl;  // Compilation error
    // std::cout << "Final i: " << i << std::endl;           // Compilation error

    // Example 2: Conditional scope
    bool condition = true;
    if (condition)
    {
        int conditionalVar = 42;
        std::cout << "In if block: " << conditionalVar << std::endl;
    }

    // Bug: conditionalVar only exists inside the if block
    // std::cout << "After if: " << conditionalVar << std::endl;  // Compilation error
}

void fixedScope()
{
    // Fixed: Declare variables in appropriate scope
    int loopVar = 0;
    int i = 0;

    for (i = 0; i < 3; ++i)
    {
        loopVar = i * 10;
        std::cout << "In loop: " << loopVar << std::endl;
    }

    std::cout << "After loop, loopVar = " << loopVar << std::endl;
    std::cout << "Final i = " << i << std::endl;

    // Fixed: Declare conditional variable outside if needed later
    int conditionalVar = 0;
    bool condition = true;

    if (condition)
    {
        conditionalVar = 42;
        std::cout << "In if block: " << conditionalVar << std::endl;
    }

    std::cout << "After if: " << conditionalVar << std::endl;
}

int main()
{
    std::cout << "Demonstrating scope (compilation errors prevented):" << std::endl;
    scopeErrors();

    std::cout << "\nWith fixed scope:" << std::endl;
    fixedScope();

    return 0;
}

Output:

Demonstrating scope (compilation errors prevented):
In loop: 0
In loop: 10
In loop: 20
In if block: 42

With fixed scope:
In loop: 0
In loop: 10
In loop: 20
After loop, loopVar = 20
Final i = 3
In if block: 42
After if: 42

Common debugging strategies for semantic errors

1. Print debugging

Add output statements to track program flow:

#include <iostream>

int findMax(int arr[], int size)
{
    std::cout << "DEBUG: findMax called with size = " << size << std::endl;

    int maxVal = arr[0];
    std::cout << "DEBUG: Initial maxVal = " << maxVal << std::endl;

    for (int i = 1; i < size; ++i)  // Bug was here: started at 0 instead of 1
    {
        std::cout << "DEBUG: Comparing arr[" << i << "] = " << arr[i]
                  << " with maxVal = " << maxVal << std::endl;

        if (arr[i] > maxVal)
        {
            maxVal = arr[i];
            std::cout << "DEBUG: New maxVal = " << maxVal << std::endl;
        }
    }

    std::cout << "DEBUG: Returning maxVal = " << maxVal << std::endl;
    return maxVal;
}

int main()
{
    int numbers[] = {3, 1, 4, 1, 5, 9};
    int result = findMax(numbers, 6);
    std::cout << "Maximum value: " << result << std::endl;

    return 0;
}

2. Rubber duck debugging

Explain your code line by line to find the error:

// "I have a function that should calculate the factorial of a number..."
int factorial(int n)
{
    // "If n is 0 or 1, return 1 - that's correct for base cases"
    if (n <= 1)
        return 1;

    // "Otherwise, return n times factorial of n-1..."
    // "Wait, let me trace through this:"
    // "factorial(3) should be 3 * factorial(2)"
    // "factorial(2) should be 2 * factorial(1)"
    // "factorial(1) should return 1"
    // "So factorial(2) = 2 * 1 = 2"
    // "And factorial(3) = 3 * 2 = 6"
    // "That looks right..."

    return n * factorial(n - 1);
}

Preventing semantic errors

1. Use meaningful variable names

// Poor: Hard to spot bugs
int calc(int x, int y)
{
    return x + y * 30;  // What does 30 represent?
}

// Better: Self-documenting code
int calculateMonthlySalary(int hourlyRate, int hoursWorked)
{
    const int averageHoursPerMonth = 160;  // More obvious what this represents
    return hourlyRate * hoursWorked * averageHoursPerMonth;  // Bug more obvious: should be (rate * hours) for total, not rate * hours * more hours
}

// Correct:
int calculateMonthlySalary(int hourlyRate, int hoursWorked)
{
    return hourlyRate * hoursWorked;
}

2. Use constants instead of magic numbers

// Poor: Magic numbers hide intent
bool isWorkingAge(int age)
{
    return age >= 16 && age <= 65;  // Why 16? Why 65?
}

// Better: Named constants
bool isWorkingAge(int age)
{
    const int MIN_WORKING_AGE = 16;
    const int MAX_WORKING_AGE = 65;

    return age >= MIN_WORKING_AGE && age <= MAX_WORKING_AGE;
}

3. Initialize variables when declaring them

// Poor: Uninitialized variables
int calculateTotal()
{
    int sum;     // Dangerous: might contain garbage
    int count;   // Dangerous: might contain garbage

    // ... code that might not set these properly

    return sum / count;  // Undefined behavior possible
}

// Better: Always initialize
int calculateTotal()
{
    int sum = 0;      // Safe: starts at known value
    int count = 0;    // Safe: starts at known value

    // ... rest of code

    if (count == 0)   // Safe: can check for division by zero
        return 0;

    return sum / count;
}

Summary

Semantic errors are logic bugs that compile but produce incorrect results:

• Logic errors: Flawed algorithms or incorrect reasoning
• Off-by-one errors: Incorrect loop bounds or array indices
• Infinite loops: Conditions that never become false
• Initialization errors: Using variables before setting values
• Assignment vs. comparison: Using = instead of ==
• Precedence errors: Misunderstanding operator order
• Array bounds errors: Accessing invalid array positions
• Parameter errors: Wrong arguments to functions
• Integer division errors: Expecting decimals from integer math
• Scope errors: Using variables outside their lifetime

Prevention strategies:

• Use meaningful names and constants
• Initialize variables when declaring them
• Add debug output to trace program execution
• Test with various inputs including edge cases
• Use parentheses to clarify operator precedence

Semantic errors are often harder to find than syntax errors, but systematic debugging and good programming practices help prevent and identify them.

Quiz

1. What's the difference between a syntax error and a semantic error?
2. What causes an off-by-one error in a loop?
3. Why does if (x = 5) always evaluate to true?
4. What happens when you access an array element at index -1?
5. How can you avoid integer division truncation when calculating averages?

Practice exercises

Find and fix the semantic errors in these code snippets:

1. Fix the bug in this grade calculator:

   char getGrade(int score) {
       if (score >= 90) return 'A';
       if (score >= 80) return 'B';
       if (score >= 70) return 'C';
       if (score >= 60) return 'D';
       return 'F';
   }
   

2. Find the error in this array sum function:

   int sumArray(int arr[], int size) {
       int sum;
       for (int i = 0; i <= size; i++) {
           sum += arr[i];
       }
       return sum;
   }
   

3. Fix this password validation function:

   bool isValidPassword(string password) {
       return password.length() > 8 && password.length() < 20;
   }
   

4. Correct this temperature conversion:

   double celsiusToFahrenheit(int celsius) {
       return celsius * 9 / 5 + 32;
   }