3.1 — Syntax and semantic errors

In this lesson, you'll learn about the two main categories of programming errors: syntax errors and semantic errors. Understanding these different types of errors is essential for becoming an effective C++ programmer and debugger.

What are programming errors?

Programming errors (also called bugs) are mistakes in code that prevent a program from working correctly. These errors can be broadly classified into two main categories:

1. Syntax errors: Mistakes in the language rules and structure
2. Semantic errors: Mistakes in the logic and meaning of the code

Think of programming languages like human languages. Syntax errors are like grammar mistakes, while semantic errors are like saying something that's grammatically correct but doesn't make logical sense.

Syntax errors

Syntax errors occur when you violate the rules of the C++ language. These errors prevent your program from compiling, so you'll catch them before your program runs.

Common syntax errors

1. Missing semicolons

#include <iostream>

int main()
{
    int x = 5  // Error: Missing semicolon
    int y = 10; // Error: Previous line prevents compilation
    
    std::cout << x + y << std::endl;
    
    return 0;
}

Compiler error:

error: expected ';' before 'int'

Fixed version:

#include <iostream>

int main()
{
    int x = 5;  // Fixed: Added semicolon
    int y = 10;
    
    std::cout << x + y << std::endl;
    
    return 0;
}

Output:

15

2. Mismatched parentheses and braces

#include <iostream>

int main()
{
    int x = 5;
    
    if (x > 0  // Error: Missing closing parenthesis
    {
        std::cout << "Positive" << std::endl;
    }
    
    return 0;
// Error: Missing closing brace for main()

Compiler error:

error: expected ')' before '{'
error: expected '}' at end of input

Fixed version:

#include <iostream>

int main()
{
    int x = 5;
    
    if (x > 0)  // Fixed: Added closing parenthesis
    {
        std::cout << "Positive" << std::endl;
    }
    
    return 0;
}  // Fixed: Added closing brace

Output:

Positive

3. Misspelled keywords and identifiers

#include <iostream>

int main()
{
    Int x = 5;  // Error: 'Int' should be 'int'
    
    std::cout << X << std::endl;  // Error: 'X' should be 'x'
    
    retrun 0;   // Error: 'retrun' should be 'return'
}

Compiler errors:

error: 'Int' does not name a type
error: 'X' was not declared in this scope
error: expected ';' before 'retrun'

Fixed version:

#include <iostream>

int main()
{
    int x = 5;  // Fixed: Corrected 'Int' to 'int'
    
    std::cout << x << std::endl;  // Fixed: Corrected 'X' to 'x'
    
    return 0;   // Fixed: Corrected 'retrun' to 'return'
}

Output:

5

4. Incorrect function calls

#include <iostream>

int addNumbers(int a, int b)
{
    return a + b;
}

int main()
{
    int result = addNumbers(5;  // Error: Missing closing parenthesis and argument
    
    std::cout << result << std::endl;
    
    return 0;
}

Compiler error:

error: expected ')' before ';'
error: too few arguments to function 'int addNumbers(int, int)'

Fixed version:

#include <iostream>

int addNumbers(int a, int b)
{
    return a + b;
}

int main()
{
    int result = addNumbers(5, 3);  // Fixed: Added second argument and closing parenthesis
    
    std::cout << result << std::endl;
    
    return 0;
}

Output:

8

Semantic errors

Semantic errors occur when your code is syntactically correct but doesn't do what you intended. These errors are much harder to find because your program compiles and runs, but produces incorrect results or unexpected behavior.

Common semantic errors

1. Logic errors

#include <iostream>

bool isEven(int number)
{
    return (number % 2 == 1);  // Error: Should be == 0 for even numbers
}

int main()
{
    std::cout << "Is 4 even? " << std::boolalpha << isEven(4) << std::endl;
    std::cout << "Is 5 even? " << std::boolalpha << isEven(5) << std::endl;
    
    return 0;
}

Output (incorrect):

Is 4 even? false
Is 5 even? true

Fixed version:

#include <iostream>

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

int main()
{
    std::cout << "Is 4 even? " << std::boolalpha << isEven(4) << std::endl;
    std::cout << "Is 5 even? " << std::boolalpha << isEven(5) << std::endl;
    
    return 0;
}

Output (correct):

Is 4 even? true
Is 5 even? false

2. Off-by-one errors

#include <iostream>

int main()
{
    std::cout << "Counting from 1 to 5:" << std::endl;
    
    // Error: Loop runs 6 times instead of 5
    for (int i = 1; i <= 5; ++i)
    {
        if (i <= 5)  // Redundant condition
            std::cout << i << " ";
    }
    
    // Error: Should count from 1 to 5, but this starts at 0
    for (int j = 0; j < 5; ++j)
    {
        std::cout << j << " ";
    }
    
    return 0;
}

Output (problematic):

Counting from 1 to 5:
1 2 3 4 5 0 1 2 3 4 

Fixed version:

#include <iostream>

int main()
{
    std::cout << "Counting from 1 to 5:" << std::endl;
    
    // Fixed: Simple loop that counts correctly
    for (int i = 1; i <= 5; ++i)
    {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

Output (correct):

Counting from 1 to 5:
1 2 3 4 5 

3. Incorrect operator usage

#include <iostream>

int main()
{
    int x = 10;
    
    // Error: Using assignment (=) instead of comparison (==)
    if (x = 5)
    {
        std::cout << "x equals 5" << std::endl;
    }
    
    std::cout << "x is now: " << x << std::endl;
    
    return 0;
}

Output (unexpected):

x equals 5
x is now: 5

Fixed version:

#include <iostream>

int main()
{
    int x = 10;
    
    // Fixed: Using comparison (==) instead of assignment (=)
    if (x == 5)
    {
        std::cout << "x equals 5" << std::endl;
    }
    else
    {
        std::cout << "x does not equal 5" << std::endl;
    }
    
    std::cout << "x is: " << x << std::endl;
    
    return 0;
}

Output (correct):

x does not equal 5
x is: 10

4. Division by zero

#include <iostream>

double divide(double a, double b)
{
    return a / b;  // Error: No check for division by zero
}

int main()
{
    double result1 = divide(10.0, 2.0);
    double result2 = divide(10.0, 0.0);  // Problematic: Division by zero
    
    std::cout << "10 / 2 = " << result1 << std::endl;
    std::cout << "10 / 0 = " << result2 << std::endl;
    
    return 0;
}

Output (problematic):

10 / 2 = 5
10 / 0 = inf

Fixed version:

#include <iostream>

double divide(double a, double b)
{
    if (b == 0.0)
    {
        std::cout << "Error: Division by zero!" << std::endl;
        return 0.0;  // Or throw an exception in more advanced code
    }
    return a / b;
}

int main()
{
    double result1 = divide(10.0, 2.0);
    double result2 = divide(10.0, 0.0);  // Now handled safely
    
    std::cout << "10 / 2 = " << result1 << std::endl;
    std::cout << "10 / 0 = " << result2 << std::endl;
    
    return 0;
}

Output (safe):

10 / 2 = 5
Error: Division by zero!
10 / 0 = 0

Comparing syntax and semantic errors

Tips for avoiding errors

Preventing syntax errors:

1. Use a good IDE: Modern IDEs highlight syntax errors as you type
2. Consistent formatting: Proper indentation makes missing braces obvious
3. Read compiler messages: They usually point directly to the problem
4. Type carefully: Double-check spelling of keywords and variable names

Preventing semantic errors:

1. Plan before coding: Think through your logic before implementing
2. Use meaningful names: Clear variable and function names reduce confusion
3. Test frequently: Run your code often with different inputs
4. Use debugger tools: Step through code to see what's actually happening
5. Peer review: Have others look at your code

Best practices for error handling

#include <iostream>

// Good practice: Defensive programming
int calculateGrade(int score)
{
    // Validate input
    if (score < 0 || score > 100)
    {
        std::cout << "Error: Score must be between 0 and 100" << std::endl;
        return -1;  // Indicate error
    }
    
    // Clear logic with explicit conditions
    if (score >= 90)
        return 'A';
    else if (score >= 80)
        return 'B';
    else if (score >= 70)
        return 'C';
    else if (score >= 60)
        return 'D';
    else
        return 'F';
}

int main()
{
    // Test with valid and invalid inputs
    std::cout << "Grade for 95: " << static_cast<char>(calculateGrade(95)) << std::endl;
    std::cout << "Grade for 150: " << calculateGrade(150) << std::endl;  // Invalid input
    
    return 0;
}

Output:

Grade for 95: A
Error: Score must be between 0 and 100
Grade for 150: -1

Summary

Understanding the difference between syntax and semantic errors is crucial for effective debugging:

• Syntax errors violate language rules and prevent compilation - they're usually easy to fix
• Semantic errors are logic mistakes that produce incorrect behavior - they're harder to find and fix
• Use tools like IDEs and debuggers to catch errors early
• Practice defensive programming to prevent common semantic errors
• Test your code thoroughly with various inputs

In the next lesson, you'll learn about the systematic debugging process for finding and fixing these errors.

Quiz

1. What's the difference between a syntax error and a semantic error?
2. Which type of error is caught at compile time?
3. Which type of error is generally harder to find and why?
4. What would happen if you compiled this code?

   int main()
   {
       int x = 5
       return 0;
   }
   

5. What's wrong with this function logically?

   bool isPositive(int num)
   {
       return num < 0;
   }
   

Practice exercises

Try to identify and fix the errors in these code snippets:

1. Syntax error practice:

   #include <iostream>
   
   int main()
   {
       int x = 10
       int y = 20;
       std::cout << x + y << std::endl
       return 0;
   }
   

2. Semantic error practice:

   #include <iostream>
   
   int getMax(int a, int b)
   {
       if (a > b)
           return b;  // What's wrong here?
       else
           return a;
   }
   
   int main()
   {
       std::cout << "Max of 5 and 10: " << getMax(5, 10) << std::endl;
       return 0;
   }
   

3. Mixed errors:

   #include <iostream>
   
   bool isPerfectSquare(int num)
   {
       for (int i = 1; i * i < num; ++i)  // Logic issue?
       {
           if (i * i = num)  // Syntax issue?
               return true;
       }
       return false
   }  // Missing something?
   

4. Create a function that calculates the area of a triangle given base and height, but includes proper error checking for negative values.