Function parameters in C++ are a crucial aspect of writing flexible and reusable code. They allow you to pass data to functions, enabling dynamic behavior based on input values.

Types of Function Parameters

C++ supports three main types of function parameters:

Pass by value
Pass by reference
Pass by pointer

1. Pass by Value

When passing arguments by value, a copy of the argument is created and passed to the function. Changes made to the parameter inside the function do not affect the original variable.

void incrementByValue(int num) {
    num++;
    // The original variable remains unchanged
}

int main() {
    int x = 5;
    incrementByValue(x);
    // x is still 5
    return 0;
}

2. Pass by Reference

Passing arguments by reference allows the function to modify the original variable. It's more efficient for large objects as it avoids copying data.

void incrementByReference(int &num) {
    num++;
    // The original variable is modified
}

int main() {
    int x = 5;
    incrementByReference(x);
    // x is now 6
    return 0;
}

3. Pass by Pointer

Passing arguments by pointer is similar to passing by reference, but it uses pointer syntax. It allows for optional modification of the original variable and can handle null values.

void incrementByPointer(int *num) {
    if (num != nullptr) {
        (*num)++;
        // The original variable is modified
    }
}

int main() {
    int x = 5;
    incrementByPointer(&x);
    // x is now 6
    return 0;
}

Default Parameters

C++ allows you to specify default values for function parameters. This feature enables you to call functions with fewer arguments than they're defined to accept.

void greet(std::string name = "Guest") {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    greet();        // Outputs: Hello, Guest!
    greet("Alice"); // Outputs: Hello, Alice!
    return 0;
}

Best Practices

Use pass by value for small, simple data types (e.g., int, char).
Use pass by const reference for larger objects when you don't need to modify them.
Use pass by reference or pointer when you need to modify the original variable.
Always initialize pointer parameters to avoid undefined behavior.
Use default parameters judiciously to improve function usability without sacrificing clarity.

Understanding function parameters is essential for writing efficient and flexible C++ code. They form the foundation for more advanced concepts like Function Overloading and Template Specialization.

Related Concepts

To deepen your understanding of C++ functions, explore these related topics: