5.4 — The as-if rule and compile-time optimization

In this lesson, you'll learn about the as-if rule, how compilers optimize code, and why understanding optimization is important for C++ programmers.

What is the as-if rule?

The as-if rule is a fundamental principle in C++ that allows the compiler to perform any optimization, as long as the observable behavior of the program remains the same as if the optimizations were not performed.

Think of it like this: the compiler can take shortcuts in how it executes your code, as long as the final result looks exactly the same to anyone observing the program's output.

Observable behavior

Observable behavior includes:

• Values written to output streams (like std::cout)
• Values written to files
• Calls to library functions with observable effects
• Access to volatile objects
• Program termination and exit codes

The compiler cannot change these aspects of your program's behavior.

Simple optimization examples

Example 1: Constant folding

The compiler can evaluate constant expressions at compile time:

#include <iostream>

int main()
{
    // What you write:
    int result = 5 + 3 * 2;
    
    // What the compiler might actually generate:
    // int result = 11;  // Calculated at compile time
    
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Output:

Result: 11

The compiler calculates 5 + 3 * 2 = 11 during compilation, not at runtime.

Example 2: Dead code elimination

The compiler can remove code that has no observable effect:

#include <iostream>

int main()
{
    int x = 10;
    int y = 20;
    int unused = x + y;  // This might be eliminated if never used
    
    std::cout << "Hello, World!" << std::endl;
    
    return 0;
}

Since unused is never used, the compiler might eliminate the calculation entirely.

Example 3: Constant propagation

The compiler can replace variables with their constant values:

#include <iostream>

int main()
{
    const int multiplier = 2;
    int value = 10;
    
    // What you write:
    int result = value * multiplier;
    
    // What the compiler might generate:
    // int result = value * 2;  // Replace multiplier with its value
    
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Output:

Result: 20

Compile-time constant expressions

Some expressions can be evaluated entirely at compile time:

#include <iostream>

int main()
{
    // These are all compile-time constant expressions
    const int daysInWeek = 7;
    const int weeksInMonth = 4;
    const int daysInMonth = daysInWeek * weeksInMonth;  // Calculated at compile time
    
    // Complex constant calculations
    const double pi = 3.14159;
    const double radius = 5.0;
    const double area = pi * radius * radius;  // Calculated at compile time
    
    std::cout << "Days in month: " << daysInMonth << std::endl;
    std::cout << "Circle area: " << area << std::endl;
    
    return 0;
}

Output:

Days in month: 28
Circle area: 78.5397

Both daysInMonth and area are calculated during compilation, not runtime.

Function inlining

The compiler might replace function calls with the actual function code:

#include <iostream>

// Small function that might be inlined
inline int square(int x)
{
    return x * x;
}

int main()
{
    int number = 5;
    
    // What you write:
    int result = square(number);
    
    // What the compiler might generate (inlining):
    // int result = number * number;
    
    std::cout << "Square of " << number << " is " << result << std::endl;
    
    return 0;
}

Output:

Square of 5 is 25

The compiler might replace the function call with the actual multiplication.

Loop optimization

Compilers can optimize loops in various ways:

Loop unrolling

#include <iostream>

int main()
{
    int sum = 0;
    
    // What you write:
    for (int i = 0; i < 4; ++i)
    {
        sum += i;
    }
    
    // What the compiler might generate (loop unrolling):
    // sum += 0;
    // sum += 1;
    // sum += 2;
    // sum += 3;
    
    std::cout << "Sum: " << sum << std::endl;
    
    return 0;
}

Output:

Sum: 6

Constant loop optimization

#include <iostream>

int main()
{
    const int iterations = 3;
    int result = 0;
    
    // What you write:
    for (int i = 0; i < iterations; ++i)
    {
        result += 10;
    }
    
    // What the compiler might generate:
    // int result = 30;  // Calculated at compile time
    
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Output:

Result: 30

Demonstrating optimization effects

Here's a program that shows potential optimization:

#include <iostream>
#include <chrono>

int calculateSum()
{
    int sum = 0;
    // This loop might be optimized away entirely
    for (int i = 1; i <= 100; ++i)
    {
        sum += i;  // Sum of 1 to 100 = 5050
    }
    return sum;
}

int main()
{
    auto start = std::chrono::high_resolution_clock::now();
    
    int result = calculateSum();
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start);
    
    std::cout << "Sum 1-100: " << result << std::endl;
    std::cout << "Time taken: " << duration.count() << " nanoseconds" << std::endl;
    
    // The compiler might replace calculateSum() with just: return 5050;
    
    return 0;
}

In optimized builds, the compiler might calculate the sum at compile time and replace the entire function with return 5050;.

Why the as-if rule matters

1. Performance benefits

#include <iostream>

int main()
{
    // Inefficient-looking code
    const double pi = 3.14159;
    const double r1 = 2.0;
    const double r2 = 3.0;
    const double r3 = 4.0;
    
    // Multiple similar calculations
    double area1 = pi * r1 * r1;
    double area2 = pi * r2 * r2;
    double area3 = pi * r3 * r3;
    
    // The compiler optimizes these to compile-time constants
    std::cout << "Areas: " << area1 << ", " << area2 << ", " << area3 << std::endl;
    
    return 0;
}

Output:

Areas: 12.5664, 28.2743, 50.2654

2. Code clarity without performance penalty

#include <iostream>

int main()
{
    // Clear, readable code
    const int secondsPerMinute = 60;
    const int minutesPerHour = 60;
    const int hoursPerDay = 24;
    
    // Expressive calculation
    const int secondsPerDay = secondsPerMinute * minutesPerHour * hoursPerDay;
    
    std::cout << "Seconds per day: " << secondsPerDay << std::endl;
    
    // Compiler calculates: 60 * 60 * 24 = 86400 at compile time
    
    return 0;
}

Output:

Seconds per day: 86400

Optimization levels

Different compiler optimization levels affect how aggressively optimizations are applied:

#include <iostream>

// This function demonstrates optimization opportunities
int expensiveCalculation(int n)
{
    int result = 0;
    for (int i = 0; i < 1000; ++i)
    {
        if (n > 10)  // Condition might be optimized
        {
            result += i * 2;
        }
        else
        {
            result += i;
        }
    }
    return result;
}

int main()
{
    // With optimization, this might be heavily optimized
    int value = expensiveCalculation(15);
    
    std::cout << "Calculated value: " << value << std::endl;
    
    return 0;
}

• No optimization (-O0): Code runs exactly as written
• Basic optimization (-O1): Simple optimizations
• Full optimization (-O2): Aggressive optimizations without size increase
• Maximum optimization (-O3): All optimizations including those that might increase size

When optimizations don't apply

Volatile variables

#include <iostream>

int main()
{
    volatile int count = 0;  // volatile prevents optimization
    
    // This loop cannot be optimized away
    for (int i = 0; i < 5; ++i)
    {
        count++;  // Each access must happen as written
    }
    
    std::cout << "Count: " << count << std::endl;
    
    return 0;
}

Functions with side effects

#include <iostream>

int printAndReturn(int value)
{
    std::cout << "Processing: " << value << std::endl;  // Side effect!
    return value * 2;
}

int main()
{
    // This cannot be optimized away because of the side effect
    int result = printAndReturn(5);
    
    std::cout << "Result: " << result << std::endl;
    
    return 0;
}

Output:

Processing: 5
Result: 10

Practical implications

1. Write clear, expressive code

Don't worry about micro-optimizations if they hurt readability:

#include <iostream>

int main()
{
    // Clear and expressive - compiler will optimize
    const double taxRate = 0.08;
    const double discountRate = 0.15;
    
    double price = 100.0;
    double taxAmount = price * taxRate;
    double discountAmount = price * discountRate;
    double finalPrice = price + taxAmount - discountAmount;
    
    std::cout << "Final price: $" << finalPrice << std::endl;
    
    return 0;
}

Output:

Final price: $93

2. Use const for optimization hints

#include <iostream>

int main()
{
    // const helps the compiler optimize
    const int arraySize = 1000;
    const double multiplier = 2.5;
    
    // Compiler knows these values won't change
    double sum = 0.0;
    for (int i = 0; i < arraySize; ++i)
    {
        sum += i * multiplier;
    }
    
    std::cout << "Sum: " << sum << std::endl;
    
    return 0;
}

Output:

Sum: 1.24875e+06

Best practices related to the as-if rule

1. Write clear, maintainable code - let the compiler handle optimization
2. Use const wherever possible - helps the compiler optimize
3. Avoid premature optimization - focus on correctness first
4. Trust the compiler - modern compilers are very sophisticated
5. Profile before optimizing - measure actual performance bottlenecks

#include <iostream>

// Good: Clear and const-correct
double calculateArea(const double radius)
{
    const double pi = 3.14159;
    return pi * radius * radius;  // Compiler can optimize this
}

int main()
{
    const double radius = 5.0;
    double area = calculateArea(radius);
    
    std::cout << "Circle area: " << area << std::endl;
    
    return 0;
}

Output:

Circle area: 78.5397

Understanding compiler behavior

Different situations where the as-if rule applies:

#include <iostream>

int main()
{
    // 1. Arithmetic simplification
    int a = 5 * 2 + 3;  // Becomes: int a = 13;
    
    // 2. Boolean simplification
    bool result = true && false;  // Becomes: bool result = false;
    
    // 3. Unreachable code removal
    if (false)
    {
        std::cout << "This will never print\n";  // Removed by compiler
    }
    
    // 4. Constant propagation
    const int x = 10;
    int y = x + 5;  // Becomes: int y = 15;
    
    std::cout << "a = " << a << ", result = " << result << ", y = " << y << std::endl;
    
    return 0;
}

Output:

a = 13, result = 0, y = 15

Summary

The as-if rule and compile-time optimization are powerful features of C++:

• The as-if rule allows compilers to optimize code as long as observable behavior is preserved
• Observable behavior includes output, file operations, and library calls with side effects
• Common optimizations include constant folding, dead code elimination, inlining, and loop optimization
• Const variables help the compiler perform optimizations
• Write clear code - the compiler will handle performance optimization
• Don't sacrifice readability for premature micro-optimizations

Understanding these concepts helps you write better C++ code that is both readable and efficient.

Quiz

1. What is the as-if rule in C++?
2. What constitutes "observable behavior" in a C++ program?
3. What is constant folding?
4. Why might the compiler remove unused variables?
5. How does the const keyword help with optimization?

Practice exercises

Try these exercises to understand optimization:

1. Write a program with constant expressions and observe how they might be optimized
2. Create functions that could be inlined and understand when inlining might occur
3. Write code with unused variables and understand when they might be eliminated
4. Compare the performance of constant calculations vs. runtime calculations