8.3 — Common if statement problems

In this lesson, you'll learn about the most common mistakes developers make with if statements, how to identify these problems, and techniques to avoid them in your own code.

Assignment vs. equality comparison

The most dangerous mistake with if statements is using assignment (=) instead of equality comparison (==).

The problem

#include <iostream>

int main()
{
    int x = 5;
    
    if (x = 3)  // BUG: Assignment, not comparison!
    {
        std::cout << "x equals 3\n";
    }
    
    std::cout << "x is now: " << x << std::endl;
    
    return 0;
}

Output:

x equals 3
x is now: 3

What happened?

• x = 3 assigns 3 to x (changing x from 5 to 3)
• The assignment operation returns the assigned value (3)
• Since 3 is non-zero, it's considered "true"
• The if block executes, even though we meant to check if x was already 3

The solution

#include <iostream>

int main()
{
    int x = 5;
    
    if (x == 3)  // Correct: Equality comparison
    {
        std::cout << "x equals 3\n";
    }
    else
    {
        std::cout << "x does not equal 3\n";
    }
    
    std::cout << "x is still: " << x << std::endl;
    
    return 0;
}

Output:

x does not equal 3
x is still: 5

Prevention technique: Yoda conditions

Some programmers use "Yoda conditions" to prevent assignment mistakes:

if (3 == x)  // If you accidentally type =, this won't compile

If you accidentally write 3 = x, the compiler will give an error because you can't assign to a literal value.

Floating-point equality comparisons

Comparing floating-point numbers for exact equality is unreliable due to precision issues.

The problem

#include <iostream>

int main()
{
    double a = 0.1 + 0.2;
    double b = 0.3;
    
    if (a == b)
    {
        std::cout << "0.1 + 0.2 equals 0.3\n";
    }
    else
    {
        std::cout << "0.1 + 0.2 does NOT equal 0.3\n";
        std::cout << "a = " << a << std::endl;
        std::cout << "b = " << b << std::endl;
    }
    
    return 0;
}

Output:

0.1 + 0.2 does NOT equal 0.3
a = 0.3
b = 0.3

Even though both values appear to be 0.3, they're actually slightly different due to floating-point representation.

The solution: Epsilon comparison

#include <iostream>
#include <cmath>  // for std::abs

bool isEqual(double a, double b, double epsilon = 0.00001)
{
    return std::abs(a - b) < epsilon;
}

int main()
{
    double a = 0.1 + 0.2;
    double b = 0.3;
    
    if (isEqual(a, b))
    {
        std::cout << "0.1 + 0.2 equals 0.3 (within tolerance)\n";
    }
    else
    {
        std::cout << "0.1 + 0.2 does NOT equal 0.3\n";
    }
    
    return 0;
}

Output:

0.1 + 0.2 equals 0.3 (within tolerance)

Dangling else problem

When you have nested if statements without braces, the else clause belongs to the nearest if.

The problem

#include <iostream>

int main()
{
    int x = 5;
    int y = 3;
    
    if (x > 0)
        if (y > 0)
            std::cout << "Both positive\n";
    else  // Which if does this else belong to?
        std::cout << "Something is not positive\n";
    
    return 0;
}

This looks like the else belongs to the first if, but it actually belongs to the second if. If x = 5 and y = -1:

Output:

Something is not positive

The solution: Always use braces

#include <iostream>

int main()
{
    int x = 5;
    int y = -1;
    
    // Clear grouping with braces
    if (x > 0)
    {
        if (y > 0)
        {
            std::cout << "Both positive\n";
        }
        else
        {
            std::cout << "x is positive, y is not\n";
        }
    }
    else
    {
        std::cout << "x is not positive\n";
    }
    
    return 0;
}

Output:

x is positive, y is not

Null statement problems

A semicolon by itself creates a null statement, which can cause unexpected behavior.

The problem

#include <iostream>

int main()
{
    int x = 5;
    
    if (x > 3);  // BUG: Semicolon creates null statement
    {
        std::cout << "This always prints!\n";
    }
    
    return 0;
}

Output:

This always prints!

The semicolon after the if creates an empty statement. The block below is not part of the if - it always executes.

The solution

#include <iostream>

int main()
{
    int x = 5;
    
    if (x > 3)  // No semicolon
    {
        std::cout << "This prints only if x > 3\n";
    }
    
    return 0;
}

Logical operator confusion

Mixing up && (AND) and || (OR) operators.

The problem

#include <iostream>

int main()
{
    int age = 25;
    bool hasLicense = false;
    
    // BUG: Using OR instead of AND
    if (age >= 16 || hasLicense)
    {
        std::cout << "You can drive!\n";
    }
    else
    {
        std::cout << "You cannot drive.\n";
    }
    
    return 0;
}

Output:

You can drive!

This is wrong! The person is 25 (age >= 16 is true) but doesn't have a license. The OR operator makes the condition true if either part is true.

The solution

#include <iostream>

int main()
{
    int age = 25;
    bool hasLicense = false;
    
    // Correct: Both conditions must be true
    if (age >= 16 && hasLicense)
    {
        std::cout << "You can drive!\n";
    }
    else
    {
        std::cout << "You cannot drive.\n";
    }
    
    return 0;
}

Output:

You cannot drive.

Integer division in conditions

When dividing integers, the result is truncated, which can cause unexpected behavior.

The problem

#include <iostream>

int main()
{
    int numerator = 3;
    int denominator = 2;
    
    if (numerator / denominator == 1.5)  // BUG: Integer division
    {
        std::cout << "3/2 equals 1.5\n";
    }
    else
    {
        std::cout << "3/2 does not equal 1.5\n";
        std::cout << "3/2 = " << numerator / denominator << std::endl;
    }
    
    return 0;
}

Output:

3/2 does not equal 1.5
3/2 = 1

Integer division 3/2 equals 1 (truncated), not 1.5.

The solution

#include <iostream>

int main()
{
    int numerator = 3;
    int denominator = 2;
    
    // Cast to double for floating-point division
    if (static_cast<double>(numerator) / denominator == 1.5)
    {
        std::cout << "3/2 equals 1.5\n";
    }
    else
    {
        std::cout << "3/2 does not equal 1.5\n";
    }
    
    return 0;
}

Output:

3/2 equals 1.5

Operator precedence confusion

Not understanding operator precedence can lead to conditions that don't behave as expected.

The problem

#include <iostream>

int main()
{
    int x = 5;
    int y = 3;
    
    // BUG: What's the precedence here?
    if (x + y > 6 && x > 4 || y < 2)
    {
        std::cout << "Condition is true\n";
    }
    else
    {
        std::cout << "Condition is false\n";
    }
    
    return 0;
}

Without clear precedence, it's hard to know what this condition actually checks.

The solution: Use parentheses for clarity

#include <iostream>

int main()
{
    int x = 5;
    int y = 3;
    
    // Clear grouping with parentheses
    if ((x + y > 6) && (x > 4) || (y < 2))
    {
        std::cout << "Condition is true\n";
    }
    else
    {
        std::cout << "Condition is false\n";
    }
    
    // Even better: break complex conditions into parts
    bool sumIsLarge = (x + y > 6);
    bool xIsLarge = (x > 4);
    bool yIsSmall = (y < 2);
    
    if ((sumIsLarge && xIsLarge) || yIsSmall)
    {
        std::cout << "Clear condition is true\n";
    }
    
    return 0;
}

Output:

Condition is true
Clear condition is true

Uninitialized variable comparisons

Using uninitialized variables in conditions leads to undefined behavior.

The problem

#include <iostream>

int main()
{
    int x;  // BUG: Uninitialized!
    
    if (x > 5)  // Undefined behavior
    {
        std::cout << "x is greater than 5\n";
    }
    else
    {
        std::cout << "x is not greater than 5\n";
    }
    
    std::cout << "x = " << x << std::endl;  // Garbage value
    
    return 0;
}

Possible Output:

x is greater than 5
x = 32767

The output is unpredictable because x contains a garbage value.

The solution: Always initialize variables

#include <iostream>

int main()
{
    int x = 0;  // Properly initialized
    
    if (x > 5)
    {
        std::cout << "x is greater than 5\n";
    }
    else
    {
        std::cout << "x is not greater than 5\n";
    }
    
    std::cout << "x = " << x << std::endl;
    
    return 0;
}

Output:

x is not greater than 5
x = 0

Boolean confusion

Misunderstanding how boolean values work in conditions.

The problem

#include <iostream>

int main()
{
    bool isReady = true;
    
    // BUG: Unnecessary comparison
    if (isReady == true)  // Redundant
    {
        std::cout << "Ready!\n";
    }
    
    // BUG: Double negative
    if (!(isReady == false))  // Confusing
    {
        std::cout << "Still ready!\n";
    }
    
    return 0;
}

The solution: Use booleans directly

#include <iostream>

int main()
{
    bool isReady = true;
    
    // Good: Direct boolean check
    if (isReady)
    {
        std::cout << "Ready!\n";
    }
    
    // Good: Clear negation
    if (!isReady)
    {
        std::cout << "Not ready!\n";
    }
    else
    {
        std::cout << "Ready to go!\n";
    }
    
    return 0;
}

Output:

Ready!
Ready to go!

Best practices to avoid problems

1. Always use braces

// Always do this
if (condition)
{
    statement;
}

// Avoid this
if (condition)
    statement;

2. Use meaningful variable names

// Good
bool hasPermission = checkUserPermission();
if (hasPermission)

// Less clear
bool p = checkUserPermission();
if (p)

3. Keep conditions simple

// Hard to understand
if (age >= 18 && hasLicense && !hasViolations && insurance.isValid() && car.isWorking())

// Easier to understand
bool canDrive = (age >= 18) && hasLicense && !hasViolations;
bool vehicleReady = insurance.isValid() && car.isWorking();

if (canDrive && vehicleReady)

4. Use parentheses for clarity

// Unclear precedence
if (a && b || c && d)

// Clear precedence
if ((a && b) || (c && d))

5. Initialize all variables

// Always initialize
int count = 0;
bool found = false;
double average = 0.0;

Debugging if statement problems

Use debugging output

#include <iostream>

int main()
{
    int x = 5;
    int y = 3;
    
    std::cout << "Debug: x = " << x << ", y = " << y << std::endl;
    
    if (x > y)
    {
        std::cout << "Debug: x > y is true\n";
        std::cout << "x is greater than y\n";
    }
    else
    {
        std::cout << "Debug: x > y is false\n";
        std::cout << "x is not greater than y\n";
    }
    
    return 0;
}

Test edge cases

#include <iostream>

void testAgeCategory(int age)
{
    std::cout << "Testing age: " << age << " -> ";
    
    if (age < 13)
        std::cout << "Child\n";
    else if (age < 20)
        std::cout << "Teenager\n";
    else
        std::cout << "Adult\n";
}

int main()
{
    // Test boundary values
    testAgeCategory(12);  // Should be Child
    testAgeCategory(13);  // Should be Teenager  
    testAgeCategory(19);  // Should be Teenager
    testAgeCategory(20);  // Should be Adult
    
    return 0;
}

Output:

Testing age: 12 -> Child
Testing age: 13 -> Teenager
Testing age: 19 -> Teenager
Testing age: 20 -> Adult

Summary

Common if statement problems include:

1. Assignment vs. equality: Use == not = for comparisons
2. Floating-point equality: Use epsilon comparison for floating-point values
3. Dangling else: Always use braces to clarify which if an else belongs to
4. Null statements: Watch out for stray semicolons
5. Logical operator confusion: Make sure you're using && and || correctly
6. Integer division: Be aware that integer division truncates
7. Operator precedence: Use parentheses to make precedence explicit
8. Uninitialized variables: Always initialize variables before use
9. Boolean confusion: Use boolean variables directly in conditions

Prevention strategies:

• Always use braces
• Initialize all variables
• Use meaningful names
• Keep conditions simple
• Use parentheses for clarity
• Test edge cases
• Add debugging output when needed

Quiz

1. What's wrong with this code: if (x = 5) instead of if (x == 5)?
2. Why shouldn't you use == to compare floating-point numbers?
3. In nested if statements without braces, which if does an else clause belong to?
4. What does a semicolon after an if statement create?
5. What's the difference between && and || operators?

Practice exercises

1. Bug hunter: Find and fix all the bugs in this code:

   #include <iostream>
   
   int main()
   {
       int age;
       if (age = 25);
           std::cout << "You are 25 years old\n";
   
       double price = 19.99;
       if (price == 19.99)
           std::cout << "Price is exactly $19.99\n";
   
       bool hasKey = true;
       if (hasKey == true && age >= 18 || hasKey == false)
           std::cout << "Access granted\n";
   
       return 0;
   }
   

2. Float comparison: Write a function that safely compares two floating-point numbers and use it to test whether (0.1 + 0.2) equals 0.3.

3. Condition simplifier: Rewrite this complex condition to be more readable:

   if (score >= 90 && attendance >= 0.8 || score >= 85 && attendance >= 0.9 && hasExtraCredit)
   

4. Edge case tester: Write a program that categorizes ages into "Child" (0-12), "Teen" (13-17), "Adult" (18-64), "Senior" (65+), and test it with boundary values.