Better Programs with Functions

The power of functions

Functions are like tools in a toolbox - each one designed for a specific purpose. Just as you wouldn't use a hammer for everything, you create different functions to handle different tasks in your program.

Consider this example without functions:

#include <iostream>

int main()
{
    // Calculate area of rectangle 1
    double length1{5.0};
    double width1{3.0};
    double area1{length1 * width1};
    std::cout << "Rectangle 1: " << length1 << " x " << width1 << " = " << area1 << '\n';

    // Calculate area of rectangle 2
    double length2{8.0};
    double width2{4.0};
    double area2{length2 * width2};
    std::cout << "Rectangle 2: " << length2 << " x " << width2 << " = " << area2 << '\n';

    // Calculate area of rectangle 3
    double length3{2.5};
    double width3{6.0};
    double area3{length3 * width3};
    std::cout << "Rectangle 3: " << length3 << " x " << width3 << " = " << area3 << '\n';
    
    return 0;
}

Now compare it with a function-based approach:

#include <iostream>

double calculateRectangleArea(double length, double width)
{
    return length * width;
}

void displayRectangleInfo(double length, double width)
{
    double area{calculateRectangleArea(length, width)};
    std::cout << "Rectangle: " << length << " x " << width << " = " << area << '\n';
}

int main()
{
    displayRectangleInfo(5.0, 3.0);
    displayRectangleInfo(8.0, 4.0);
    displayRectangleInfo(2.5, 6.0);
    
    return 0;
}

Output (both versions):

Rectangle: 5 x 3 = 15
Rectangle: 8 x 4 = 32
Rectangle: 2.5 x 6 = 15

The function-based version is shorter, clearer, and much more maintainable.

Key benefits of functions

1. Code Reusability

Functions let you write code once and use it many times:

#include <iostream>

double convertCelsiusToFahrenheit(double celsius)
{
    return celsius * 9.0 / 5.0 + 32.0;
}

int main()
{
    // Use the same function for different temperatures
    std::cout << "Water freezes at: " << convertCelsiusToFahrenheit(0.0) << "°F" << '\n';
    std::cout << "Room temperature: " << convertCelsiusToFahrenheit(20.0) << "°F" << '\n';
    std::cout << "Body temperature: " << convertCelsiusToFahrenheit(37.0) << "°F" << '\n';
    std::cout << "Water boils at: " << convertCelsiusToFahrenheit(100.0) << "°F" << '\n';
    
    return 0;
}

Output:

Water freezes at: 32°F
Room temperature: 68°F
Body temperature: 98.6°F
Water boils at: 212°F

2. Modularity and Organization

Functions break complex problems into manageable pieces:

#include <iostream>

// Each function has a clear, single responsibility
double getRadius()
{
    std::cout << "Enter circle radius: ";
    double radius{};
    std::cin >> radius;
    return radius;
}

double calculateCircleArea(double radius)
{
    double PI{3.14159};
    return PI * radius * radius;
}

double calculateCircleCircumference(double radius)
{
    double PI{3.14159};
    return 2 * PI * radius;
}

void displayResults(double radius, double area, double circumference)
{
    std::cout << "\nCircle with radius " << radius << ":" << '\n';
    std::cout << "Area: " << area << '\n';
    std::cout << "Circumference: " << circumference << '\n';
}

int main()
{
    double radius{getRadius()};
    double area{calculateCircleArea(radius)};
    double circumference{calculateCircleCircumference(radius)};
    displayResults(radius, area, circumference);
    
    return 0;
}

3. Easier Testing and Debugging

Functions can be tested independently:

#include <iostream>

int findMaximum(int a, int b, int c)
{
    int max{a};
    if (b > max)
        max = b;
    if (c > max)
        max = c;
    return max;
}

void testFindMaximum(int a, int b, int c, int expected)
{
    int result{findMaximum(a, b, c)};
    std::cout << "findMaximum(" << a << ", " << b << ", " << c << ") = " << result << " (expected: " << expected << ")" << '\n';
}

int main()
{
    std::cout << "Testing findMaximum function:" << '\n';

    testFindMaximum(5, 3, 8, 8);
    testFindMaximum(10, 10, 10, 10);
    testFindMaximum(-1, -5, -3, -1);

    return 0;
}

Output:

Testing findMaximum function:
findMaximum(5, 3, 8) = 8 (expected: 8)
findMaximum(10, 10, 10) = 10 (expected: 10)
findMaximum(-1, -5, -3) = -1 (expected: -1)

4. Abstraction and Simplification

Functions hide complexity behind simple interfaces:

#include <iostream>

// Complex calculation hidden inside a function
double calculateCompoundInterest(double principal, double rate, int compoundFreq, int years)
{
    // Formula: A = P(1 + r/n)^(nt)
    double rateDecimal{rate / 100.0};
    double base{1.0 + (rateDecimal / compoundFreq)};
    int totalPeriods{compoundFreq * years};

    double amount{principal};
    for (int i{0}; i < totalPeriods; ++i)
    {
        amount *= base;
    }
    
    return amount - principal;  // Return just the interest
}

int main()
{
    // Simple to use, despite complex calculation inside
    double interest{calculateCompoundInterest(1000.0, 5.0, 12, 2)};
    std::cout << "Compound interest earned: $" << interest << '\n';
    
    return 0;
}

5. Maintainability

When you need to change logic, you only change it in one place:

#include <iostream>

// If tax rate changes, you only need to update this function
double calculateTax(double amount)
{
    double taxRate{0.08};  // 8% tax rate
    return amount * taxRate;
}

double calculateTotal(double subtotal)
{
    double tax{calculateTax(subtotal)};
    return subtotal + tax;
}

void displayReceipt(double subtotal)
{
    double tax{calculateTax(subtotal)};
    double total{calculateTotal(subtotal)};
    
    std::cout << "Subtotal: $" << subtotal << '\n';
    std::cout << "Tax: $" << tax << '\n';
    std::cout << "Total: $" << total << '\n';
}

int main()
{
    displayReceipt(100.0);
    displayReceipt(50.0);
    
    return 0;
}

Output:

Subtotal: $100
Tax: $8
Total: $108
Subtotal: $50
Tax: $4
Total: $54

Principles for effective functions

1. Single Responsibility Principle - Each function should do one thing well
2. Clear and Descriptive Names - Function names should explain what they do
3. Keep Functions Small and Focused - Smaller functions are easier to understand and test
4. Minimize Dependencies - Functions should depend on their parameters, not external state

// Each function has one clear purpose
// With clear, descriptive names
double calculateMonthlyPayment(double principal, double rate, int months)
{
    if (rate == 0) return principal / months;

    double monthlyRate{rate / 100.0 / 12.0};
    return principal * monthlyRate / (1 - pow(1 + monthlyRate, -months));
}

double globalYear;

// Small, focused functions
// With minimal dependencies
bool isLeapYear(int year)
{
    // Do not use globalYear, rely on the parameters passed in.
    return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
}

When to create a function

You should consider creating a function when:

• You find yourself copying and pasting code
• A block of code has a clear, single purpose
• You want to test a specific calculation or logic
• Code is getting too complex to follow easily
• You need to hide implementation details

#include <iostream>

// Good: Worth creating a function
double calculateTip(double billAmount, double tipPercent)
{
    return billAmount * (tipPercent / 100.0);
}

int main()
{
    // Used multiple times - function is worthwhile
    std::cout << "Bill $50, 15% tip: $" << calculateTip(50.0, 15.0) << '\n';
    std::cout << "Bill $100, 20% tip: $" << calculateTip(100.0, 20.0) << '\n';
    std::cout << "Bill $25, 18% tip: $" << calculateTip(25.0, 18.0) << '\n';
    
    // This doesn't need a function - used only once
    std::cout << "Program complete." << '\n';
    
    return 0;
}

Summary

Functions are essential for writing good C++ programs because they provide:

Key Benefits:

• Reusability: Write once, use many times
• Organization: Break complex problems into manageable pieces
• Testing: Test individual components independently
• Abstraction: Hide complexity behind simple interfaces
• Maintainability: Change logic in one place

Design Principles:

• Single responsibility: One function, one purpose
• Clear naming: Function names should explain what they do
• Small and focused: Easier to understand and debug
• Minimize dependencies: Depend on parameters, not global state

When to use functions:

• Repeated code
• Clear, single-purpose tasks
• Complex calculations that can be broken down
• Code that benefits from being tested independently

Remember: Good functions make your code more readable, reliable, and maintainable. They're not just about avoiding repetition - they're about creating clear, understandable programs.