Mastering Parameters - Default Values and References | CodeSignal Learn

Mastering Parameters - Default Values and References | CodeSignal Learn

Lesson Introduction

In this lesson, we'll dive into function parameters in C++, focusing on default values and references . These concepts help you write more flexible and efficient functions. By the end, you'll know how to set default values for parameters and modify variables directly by passing them by reference.

Default Values in Function Parameters

In C++, you can give function parameters default values. If you don't provide a value when calling the function, the default is used. Imagine a function that prints a message. Sometimes, you might want to use a default message if none is provided: C++ #include <iostream> void displayMessage(std::string message = "Hello, World!") {std::cout << message << std::endl;} int main() {displayMessage(); // Outputs: Hello, World! displayMessage("Hi there!"); // Outputs: Hi there! return 0;} Here, displayMessage has a default value of "Hello, World!" for its message parameter. When displayMessage is called without an argument, it prints the default message. With an argument like "Hi there!", it prints that instead. Default values make functions flexible, reducing the need for additional function variants.

Potential Pitfalls

In C++, parameters with default values must be defined after any parameters without default values. This is important to ensure the function calls are unambiguous. Here is an incorrectly defined function with a parameter with a default value appearing before a parameter without a default value: C++ #include <iostream> // This will cause a compilation error void printDetails(std::string country = "Unknown", std::string name, int age) {std::cout << "Name: " << name << ", Age: " << age << ", Country: " << country << std::endl;} int main() {// Compilation will fail printDetails("USA", "Alice", 30); return 0;} In the incorrect example, the compiler will produce an error because it cannot determine how to handle the default parameter if it precedes non-default parameters. Ensuring that parameters with default values are positioned after any non-default parameters allows the calls to the function to be clear and prevents any ambiguity for the compiler. Here is a corrected version where the parameter with a default value comes after parameters without defaults: C++ #include <iostream> void printDetails(std::string name, int age, std::string country = "Unknown") {std::cout << "Name: " << name << ", Age: " << age << ", Country: " << country << std::endl;} int main() {printDetails("Alice", 30); // Outputs: Name: Alice, Age: 30, Country: Unknown printDetails("Bob", 25, "USA"); // Outputs: Name: Bob, Age: 25, Country: USA return 0;}

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

References in Function Parameters

References let you pass parameters by reference, meaning the function works with the original variable, not a copy. This allows the function to directly modify the original variable’s value. Consider a function that increases a number by one: #include <iostream> void increment(int &value) {value++;} int main() {int num = 10; increment(num); std::cout << num << std::endl; // Outputs: 11 return 0;} Here, increment takes an int parameter by reference, shown by the & symbol before value . When you call increment(num), the actual value of num is incremented, not just a copy. Now, let's see the difference when the function receives without reference: #include <iostream> void incrementCopy(int value) {value++;} int main() {int num = 10; incrementCopy(num); std::cout << num << std::endl; // Outputs: 10 return 0;} In this case, incrementCopy takes an int parameter by value, so the passed variable num is not modified. Passing by reference is useful when you need to modify the original value. It’s like sharing a toy with a friend instead of giving them a duplicate; any changes affect the original toy.

Boosting Efficiency with References

In addition to allowing functions to modify original variables, passing by reference can boost efficiency, especially with large data types like std::string . When you pass by reference, the function works with the original data rather than making a copy, saving memory and processing time. You can use a' const' reference to prevent the function from modifying the original data when it doesn't need to. This ensures that the data is not accidentally changed while still gaining the efficiency benefits. Here's an example: #include <iostream> void printGreeting(const std::string &name) {std::cout << "Hello, " << name << "!" << std::endl;} int main() {std::string userName = "Alice"; printGreeting(userName); // Outputs: Hello, Alice! return 0;} In this example, printGreeting takes a const reference to a string . The const keyword ensures that name cannot be modified within the function. Passing by const reference avoids the overhead of copying the string while guaranteeing that the original string remains unchanged. Using const references is particularly important when dealing with large objects or when you want to protect the data from being modified. It's like showing someone a book without letting them make any changes to its pages.

C++

#include <iostream>

void printGreeting(const std::string &name) {
    std::cout << "Hello, " << name << "!" << std::endl;
}

int main() {
    std::string userName = "Alice";
    printGreeting(userName);  // Outputs: Hello, Alice!
    return 0;
}