Перегрузка функций

Перегрузка функций (function overloading) в C++ позволяет определять несколько функций с одним и тем же именем, но с разными параметрами. Это позволяет создавать функции, которые могут обрабатывать различные типы данных или различные количества аргументов.

Основные правила перегрузки функций

Различие в параметрах: Перегруженные функции должны отличаться набором параметров (типами, количеством или порядком параметров). Возвращаемый тип не используется для различения перегруженных функций.
Типы параметров: Компилятор использует типы параметров для разрешения вызовов перегруженных функций.

Примеры перегрузки функций

Пример 1: Перегрузка по типу параметров

#include <iostream>
 
void print(int i) {
    std::cout << "Integer: " << i << std::endl;
}
 
void print(double d) {
    std::cout << "Double: " << d << std::endl;
}
 
void print(const std::string &s) {
    std::cout << "String: " << s << std::endl;
}
 
int main() {
    print(42);             // Вызов print(int)
    print(3.14);           // Вызов print(double)
    print("Hello");        // Вызов print(const std::string &)
    return 0;
}

Пример 2: Перегрузка по количеству параметров

#include <iostream>
 
void display(const std::string &s) {
    std::cout << "Message: " << s << std::endl;
}
 
void display(const std::string &s, int n) {
    std::cout << "Message: " << s << ", Number: " << n << std::endl;
}
 
int main() {
    display("Hello");       // Вызов display(const std::string &)
    display("Hello", 42);   // Вызов display(const std::string &, int)
    return 0;
}

Пример 3: Перегрузка по порядку параметров

#include <iostream>
 
void calculate(int a, double b) {
    std::cout << "Int and Double: " << a << ", " << b << std::endl;
}
 
void calculate(double a, int b) {
    std::cout << "Double and Int: " << a << ", " << b << std::endl;
}
 
int main() {
    calculate(10, 3.14);    // Вызов calculate(int, double)
    calculate(3.14, 10);    // Вызов calculate(double, int)
    return 0;
}

Важно помнить

Аргументы по умолчанию:
- Аргументы по умолчанию могут усложнить разрешение перегруженных функций. Компилятор должен однозначно различать перегруженные функции на основе переданных аргументов.
Перегрузка и типы указателей:
- Перегруженные функции могут различаться по типам указателей и ссылок.

Пример перегрузки с указателями

#include <iostream>
 
void process(int *p) {
    std::cout << "Pointer to int: " << *p << std::endl;
}
 
void process(double *p) {
    std::cout << "Pointer to double: " << *p << std::endl;
}
 
int main() {
    int a = 10;
    double b = 3.14;
 
    process(&a);   // Вызов process(int *)
    process(&b);   // Вызов process(double *)
    return 0;
}

StudC++

Проводник