C++ for C Developers |Lesson 3: Function Overloading & Defaults

Goal: Learn how C++ allows you to define multiple functions with the same name (overloading) and how to provide default values for function parameters, making your function calls more flexible.

1. The C Way (Limitation)

In C, every function in a given scope must have a unique name. If you want to perform a similar operation on different data types, you need distinct function names:

#include <stdio.h>

void print_int(int value) {
    printf("Integer: %d\n", value);
}

void print_double(double value) {
    printf("Double: %f\n", value);
}

// You'd need print_string, print_char, etc.

int main() {
    print_int(10);
    print_double(3.14);
    return 0;
}

This can lead to many function names for conceptually similar actions.

2. C++ Function Overloading

C++ allows you to define multiple functions with the same name, as long as their parameter lists differ in either the number, type, or order of parameters. This is called function overloading. The compiler determines which version to call based on the arguments you provide.

flowchart TD
    A("Function Name: print") --> B1("print(int)")
    A --> B2("print(double)")
    A --> B3("print(std::string)")
    B1 --> C1("Called with: print(42)")
    B2 --> C2("Called with: print(3.14)")
    B3 --> C3("Called with: print('Hello')")

The combination of the function name and its parameter types is called the function signature. Overloaded functions must have different signatures. Note: The return type alone is NOT part of the signature for overloading purposes.

#include <iostream>
#include <string>

// Overloaded 'print' functions
void print(int value) {
    std::cout << "Integer: " << value << std::endl;
}

void print(double value) {
    std::cout << "Double: " << value << std::endl;
}

void print(const std::string& value) { // Takes a string by const reference (efficient)
    std::cout << "String: " << value << std::endl;
}

// Another example: Overloaded 'add'
int add(int a, int b) {
    std::cout << "Adding integers: ";
    return a + b;
}

double add(double a, double b) {
    std::cout << "Adding doubles: ";
    return a + b;
}

int main() {
    print(100);          // Calls print(int)
    print(3.14159);      // Calls print(double)
    print("Hello C++!"); // Calls print(const std::string&) - C-style literal implicitly converts

    int sum_i = add(5, 3);         // Calls add(int, int)
    double sum_d = add(2.5, 1.5); // Calls add(double, double)

    std::cout << sum_i << std::endl;
    std::cout << sum_d << std::endl;

    // What about this?
    // print(5.0f); // 'f' denotes float. Might call print(double) via promotion,
                    // or cause ambiguity if a print(float) also existed.

    return 0;
}

Benefits of Overloading:

• Readability: Use the same logical name for operations on different types (e.g., print, add, max).
• Convenience: Simplifies the calling code; you don’t need to remember slightly different names.
• Extensibility: Used extensively in the C++ Standard Library (e.g., constructors for classes).

Important Notes on Overloading:

• You cannot overload functions based only on their return type. C++// ILLEGAL - Cannot overload based on return type only // int get_value() { return 1; } // double get_value() { return 2.0; }
• Be mindful of potential ambiguity. If the compiler can’t uniquely determine which overloaded function to call based on the arguments (e.g., due to implicit type conversions), it will result in a compile-time error.

3. Default Function Arguments

C++ allows you to specify default values for function parameters directly in the function declaration (usually in a header file, .h or .hpp). If a caller doesn’t provide an argument for a parameter with a default value, the default is used automatically.

flowchart TD
    A("Function: setup_network(ip, port=8080, logging=false)")
    A --> B1("Call: setup_network('192.168.1.100')")
    B1 --> C1("Uses port=8080, logging=false")
    A --> B2("Call: setup_network('10.0.0.5', 9000)")
    B2 --> C2("Uses logging=false")
    A --> B3("Call: setup_network('server.com', 443, true)")
    B3 --> C3("All arguments provided")

Rule: Parameters with default arguments must come after parameters without default arguments. Once you give a parameter a default value, all subsequent parameters in the declaration must also have default values.

#include <iostream>
#include <string>

// Function declaration (e.g., in a .hpp file)
// Parameters with defaults must be at the end.
void setup_network(
    const std::string& ip_address, // Mandatory parameter
    int port = 8080,               // Default value is 8080
    bool enable_logging = false    // Default value is false
);

// Function definition (e.g., in a .cpp file)
// Default values are NOT repeated in the definition.
void setup_network(const std::string& ip_address, int port, bool enable_logging) {
    std::cout << "Setting up network connection:\n"
              << "  IP Address: " << ip_address << "\n"
              << "  Port: " << port << "\n"
              << "  Logging: " << (enable_logging ? "Enabled" : "Disabled") << std::endl;
    // ... actual setup logic ...
}

int main() {
    // Call using only the mandatory argument
    setup_network("192.168.1.100");
    // Output: Port: 8080, Logging: Disabled (Defaults used)

    std::cout << "\n";

    // Call providing the port, but using default for logging
    setup_network("10.0.0.5", 9000);
    // Output: Port: 9000, Logging: Disabled (Default used)

    std::cout << "\n";

    // Call providing all arguments
    setup_network("server.example.com", 443, true);
    // Output: Port: 443, Logging: Enabled (No defaults used)

    // ILLEGAL: Cannot skip a default argument in the middle
    // setup_network("127.0.0.1", , true); // Compile error!

    return 0;
}

Benefits of Default Arguments:

• Simplicity: Makes function calls less verbose when common values are acceptable.
• Flexibility: Allows functions to evolve by adding new parameters with default values without breaking existing code that calls the function with fewer arguments.
• Reduces Need for Overloads: Sometimes, default arguments can replace the need for multiple overloaded functions that differ only by the absence of trailing parameters.

Comparison Summary:

classDiagram
    class C {
        +No Function Overloading
        +No Default Arguments
        +Distinct Function Names Required
    }
    class Cpp {
        +Function Overloading Supported
        +Default Arguments Allowed
        +Cleaner & Flexible Function Calls
    }

Summary of Lesson 3:

• Function Overloading lets you define multiple functions with the same name but different parameter lists (signature). The compiler chooses the correct one based on the call.
• Overloading improves code readability and flexibility by allowing conceptually similar operations to share a name.
• Default Arguments allow you to provide default values for function parameters in the declaration. These parameters must be at the end of the parameter list.
• Default arguments simplify function calls when standard values are often used and allow for easier backward compatibility when adding new options to functions.

Next Lesson: We’ll tackle C++’s approach to dynamic memory management using new and delete, contrasting it with C’s malloc and free, and introduce the fundamental C++ concept of RAII (Resource Acquisition Is Initialization).

More Sources

cppreference – Function Overloading: https://en.cppreference.com/w/cpp/language/overloading

Learn C++ – Default Arguments: https://www.learncpp.com/cpp-tutorial/default-arguments/