Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Learn Positional and Default Arguments | Function Arguments Specification
C++ Functions
course content

Course Content

C++ Functions

C++ Functions

1. Introduction
What is Function in C++?How to Create Function in C++?Simple Function CreationVariable ScopesUnderstanding Variable Scopes
2. Function Arguments Specification
Positional and Default ArgumentsPassing Arguments by Value/Pointer/ReferenceConstant Function ArgumentsPassing Static Array as an Argument of the FunctionPassing Dynamic Array as an Argument of the FunctionWhy Do We Need Array Size as an Argument?Passing Custom Structures as Arguments
3. Function Return Values Specification
Returning Values With Simple Data TypesReturning Arrays from the FunctionReturn Custom Data TypesVoid Return Type
4. Some Advanced Topics
Function OverloadingFunction Overloading PracticeRecursionLambda Functions

book
Positional and Default Arguments

Positional arguments are a way of passing values to a function in a specific order based on the function's signature.

They are called "positional" because the values are associated with parameters according to their positions in the parameter list of function signature. The position of each argument determines which parameter it corresponds to.

cpp

main

copy

              
123456789101112131415161718192021

            
#include <iostream>

// Function that takes two positional arguments
float divide(float a, float b)
{
    if (b == 0) {
        std::cout << "Error: Division by zero is not allowed" << std::endl;
        return 0;
    }
    return a / b;
}

int main()
{
    float x = 8;
    float y = 4;

    // Calling the 'divide' function with two positional arguments
    float result = divide(x, y);
    std::cout << "The result is: " << result << std::endl;
}

You can conduct a small experiment: change the order of passing arguments to the function (use divide (y, x) instead of divide(x, y)), and you will see that the result has changed. This is precisely the essence of positional arguments: the order of passing parameters to the function is important, directly affecting its result.

Default arguments

Default arguments in C++ allow you to specify default values for function parameters. When you provide default values for parameters in a function declaration, it means that if a caller does not explicitly pass an argument for that parameter when calling the function, the default value will be used instead. You can provide a default value by simply instantiating the required argument with some value in the function signature.

Let's consider an example based on our divide() function:

cpp

main

copy

              
123456789101112131415161718192021

            
#include <iostream>

// Added the third default argument with specified value
float divide(float a, float b, bool divideByZero = false) {
    if (b == 0 && !divideByZero) {
        std::cerr << "Error: Division by zero is not allowed." << std::endl;
        return 0;
    }
    else if (b == 0 && divideByZero) 
        return a / 0.0000001;
    else
        return a / b;
}

int main() {
	float result1 = divide(51, 0.0, true); // Division by zero allowed
    std::cout << "Allowed: " << result1 << std::endl;

    float result2 = divide(7.0, 0.0); // Default behavior (Error message)
    std::cout << "Default: " << result2 << std::endl;
}

We can see that divideByZero argument has a specified false default value, and we can ignore it when calling the function. But if we want to avoid an error and continue the calculation, we can set divideByZero=true at the end of the parameter list.

Note

It is important that all default arguments are located after the positional ones in the list of parameters. Otherwise, the compiler will throw an error.

question mark

What will be the result of executing the following code

Select the correct answer

Everything was clear?

How can we improve it?

Thanks for your feedback!

SectionΒ 2. ChapterΒ 1

Ask AI

expand
ChatGPT

Ask anything or try one of the suggested questions to begin our chat

course content

Course Content

C++ Functions

C++ Functions

1. Introduction
What is Function in C++?How to Create Function in C++?Simple Function CreationVariable ScopesUnderstanding Variable Scopes
2. Function Arguments Specification
Positional and Default ArgumentsPassing Arguments by Value/Pointer/ReferenceConstant Function ArgumentsPassing Static Array as an Argument of the FunctionPassing Dynamic Array as an Argument of the FunctionWhy Do We Need Array Size as an Argument?Passing Custom Structures as Arguments
3. Function Return Values Specification
Returning Values With Simple Data TypesReturning Arrays from the FunctionReturn Custom Data TypesVoid Return Type
4. Some Advanced Topics
Function OverloadingFunction Overloading PracticeRecursionLambda Functions

book
Positional and Default Arguments

Positional arguments are a way of passing values to a function in a specific order based on the function's signature.

They are called "positional" because the values are associated with parameters according to their positions in the parameter list of function signature. The position of each argument determines which parameter it corresponds to.

cpp

main

copy

              
123456789101112131415161718192021

            
#include <iostream>

// Function that takes two positional arguments
float divide(float a, float b)
{
    if (b == 0) {
        std::cout << "Error: Division by zero is not allowed" << std::endl;
        return 0;
    }
    return a / b;
}

int main()
{
    float x = 8;
    float y = 4;

    // Calling the 'divide' function with two positional arguments
    float result = divide(x, y);
    std::cout << "The result is: " << result << std::endl;
}

You can conduct a small experiment: change the order of passing arguments to the function (use divide (y, x) instead of divide(x, y)), and you will see that the result has changed. This is precisely the essence of positional arguments: the order of passing parameters to the function is important, directly affecting its result.

Default arguments

Default arguments in C++ allow you to specify default values for function parameters. When you provide default values for parameters in a function declaration, it means that if a caller does not explicitly pass an argument for that parameter when calling the function, the default value will be used instead. You can provide a default value by simply instantiating the required argument with some value in the function signature.

Let's consider an example based on our divide() function:

cpp

main

copy

              
123456789101112131415161718192021

            
#include <iostream>

// Added the third default argument with specified value
float divide(float a, float b, bool divideByZero = false) {
    if (b == 0 && !divideByZero) {
        std::cerr << "Error: Division by zero is not allowed." << std::endl;
        return 0;
    }
    else if (b == 0 && divideByZero) 
        return a / 0.0000001;
    else
        return a / b;
}

int main() {
	float result1 = divide(51, 0.0, true); // Division by zero allowed
    std::cout << "Allowed: " << result1 << std::endl;

    float result2 = divide(7.0, 0.0); // Default behavior (Error message)
    std::cout << "Default: " << result2 << std::endl;
}

We can see that divideByZero argument has a specified false default value, and we can ignore it when calling the function. But if we want to avoid an error and continue the calculation, we can set divideByZero=true at the end of the parameter list.

Note

It is important that all default arguments are located after the positional ones in the list of parameters. Otherwise, the compiler will throw an error.

question mark

What will be the result of executing the following code

Select the correct answer

Everything was clear?

How can we improve it?

Thanks for your feedback!

SectionΒ 2. ChapterΒ 1
We're sorry to hear that something went wrong. What happened?
some-alt