Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Вивчайте Function Overloading | Some Advanced Topics
C++ Functions

book
Function Overloading

Function overloading in C++ allows multiple functions with the same name but different parameters to be defined within the same scope. It enables you to create functions that perform similar tasks but can handle different data types or numbers of parameters. Overloading enhances code readability, reusability, and flexibility.

Here's why function overloading is useful:

  1. Parameter Variation: Functions can be tailored to handle different data types or a different number of parameters, enabling more versatile usage.
  2. Readability: By giving the same name to functions with similar functionalities, code becomes more intuitive and easier to understand.
  3. Code Reusability: Functions can be reused for various data types or parameter combinations, promoting efficient code reuse.

How to overload a function?

A function is considered an overload of another function if:

  1. These functions have the same name.
  2. At least one of the following is true:

These functions have arguments of different types.

cpp

main

copy
#include <iostream>

// Function with one integer parameter
void processValue(int num) {
std::cout << "Processing integer: " << num << std::endl;
}

// Overloaded function with one double parameter
void processValue(double num) {
std::cout << "Processing double: " << num << std::endl;
}

int main() {
// Function calls with different data types
int intValue = 5;
double doubleValue = 3.14;

// Calls the first version of processValue
processValue(intValue);

// Calls the second version of processValue
processValue(doubleValue);
}
1234567891011121314151617181920212223
#include <iostream> // Function with one integer parameter void processValue(int num) { std::cout << "Processing integer: " << num << std::endl; } // Overloaded function with one double parameter void processValue(double num) { std::cout << "Processing double: " << num << std::endl; } int main() { // Function calls with different data types int intValue = 5; double doubleValue = 3.14; // Calls the first version of processValue processValue(intValue); // Calls the second version of processValue processValue(doubleValue); }

These functions have the same argument types, but these arguments have a different order in the function signature.

cpp

main

copy
#include <iostream>

// Overloaded function with a different number of arguments
void processValue(int num, std::string text) {
std::cout << "Integer and string: " << num << ", " << text << std::endl;
}

// Overloaded function with different arguments order
void processValue(std::string text, int num) {
std::cout << "String and integer: " << text << ", " << num << std::endl;
}

int main() {
// Function calls with different data types and numbers of arguments
int intValue = 5;
std::string stringValue = "Hello";

// Calls the third version of processValue
processValue(intValue, stringValue);

// Calls the forth version of processValue
processValue(stringValue, intValue);
}
123456789101112131415161718192021222324
#include <iostream> // Overloaded function with a different number of arguments void processValue(int num, std::string text) { std::cout << "Integer and string: " << num << ", " << text << std::endl; } // Overloaded function with different arguments order void processValue(std::string text, int num) { std::cout << "String and integer: " << text << ", " << num << std::endl; } int main() { // Function calls with different data types and numbers of arguments int intValue = 5; std::string stringValue = "Hello"; // Calls the third version of processValue processValue(intValue, stringValue); // Calls the forth version of processValue processValue(stringValue, intValue); }

Remember

To overload the function they have to have the same name

Все було зрозуміло?

Як ми можемо покращити це?

Дякуємо за ваш відгук!

Секція 4. Розділ 1
some-alt