C ++ — гибкий язык программирования общего назначения. Этот язык программирования был первоначально создан Бьярном Страуструпом, датским ученым-компьютерщиком, еще в 1985 году. C ++ поддерживает полиморфизм, наследование и многое другое. В этой статье рассматривается перегрузка функций для достижения полиморфизма во время компиляции в языке программирования C ++.
Что такое функция?
Функция — это не что иное, как определенный фрагмент кода, который выполняет конкретную задачу на основе предоставленных входных данных, и он возвращает запрошенные результаты пользователю в форме вывода. Функции используются для устранения повторяющегося кода в больших базах кода.
После определения функции вы можете повторно использовать ее позже, либо в той же программе, либо в другой программе.
Синтаксис функции
Функция в C ++ имеет следующий синтаксис:
returnType functionName(parameter_list)
{
…………………
…………………
return return_value;
}
Операторы returnType, parameter_list и return необязательны. Функция в C ++ может возвращать не более одного значения. Если функция не возвращает никакого значения, returnType должен быть определен как void.
Что такое перегрузка функций?
В C ++ несколько определений функций могут иметь одно и то же имя, но с разными параметрами. Это называется перегрузкой функции. С помощью функции перегрузки функций полиморфизм времени компиляции может быть достигнут в C ++.
Функции могут быть перегружены следующими способами:
- Количество параметров может быть разным.
- Тип данных параметров может быть разным.
- Последовательность параметров может быть разной.
Однако возвращаемое значение не учитывается при перегрузке функции.
Перегружены следующие функции:
- int сложение (int a, int b)
- добавление поплавка (float f, gloat g)
- сложение с плавающей запятой (float f, int i)
- сложение с плавающей запятой (int i, float f)
- int сложение (int a, int b, int c)
- добавление поплавка (float f, float g, float h)
Как видите, с помощью функции перегрузки функций в C ++ может быть несколько определений / функций с одним и тем же именем функции и в одной области.
Без функции перегрузки функций вам нужно было бы написать отдельную функцию [например, add_1 (), addition_2 () и т. Д.] Для каждого варианта. Например, вам может потребоваться написать add_1 (), чтобы добавить два целых числа, add_2 (), чтобы добавить два числа с плавающей запятой, и так далее. Однако, как вы можете видеть выше, функцию перегрузки функции можно использовать для определения нескольких вариантов функции «add ()», сохраняя при этом то же имя функции.
Следующие функции не считаются перегруженными, поскольку единственное различие между ними — это тип возвращаемого значения (тип возвращаемого значения не учитывается при перегрузке функций в C ++):
- int сложение (int a, int b)
- сложение с плавающей запятой (int a, int b)
Примеры
Теперь, когда вы понимаете концепцию перегрузки функций, мы рассмотрим несколько рабочих примеров программ, чтобы лучше понять эту концепцию. Мы рассмотрим следующие примеры:
- Пример 1: простая функция
- Пример 2: Простая функция сложения
- Пример 3: Перегрузка функции (1)
- Пример 4: Перегрузка функции (2)
- Пример 5: Функциональная перегрузка (3)
Первые два примера объясняют, как обычные функции работают в C ++, а последние три примера демонстрируют возможность перегрузки функций в C ++.
Пример 1: простая функция
В этом примере мы продемонстрируем, как можно определить и вызвать простую функцию в C ++. Мы определим класс под названием «Display» и общедоступную функцию под названием «display ()». Из функции «main ()» мы вызовем функцию «display ()» с помощью объекта класса «Display» (d).
#include <iostream>
using namespace std;
class Display
{
public:
void display()
{
cout << «Hello World!» << endl;
}
};
int main()
{
Display d;
d.display();
return 0;
}
Пример 2: Простая функция сложения
В этом примере мы продемонстрируем, как определить простую функцию «сложение ()» в C ++. Мы определим класс под названием «DemoAdd» и общедоступную функцию под названием «add ()». Из функции «main ()» мы вызовем функцию «add ()» с помощью объекта класса «DemoAdd» (d).
В этом примере текущая реализация функции «сложение ()» принимает только два целочисленных параметра. Это означает, что текущая функция «сложение ()» способна складывать только два целых числа.
Чтобы добавить три целых числа вместо двух, можно определить функцию с другим именем, например, «add_1 ()». В C ++ функция может быть перегружена, что означает, что может быть определено другое определение функции «add ()» для добавления трех целых чисел с сохранением того же имени, то есть «add ()». В следующем примере мы рассмотрим, как перегрузить функцию «сложение ()».
#include <iostream>
using namespace std;
class DemoAdd
{
public:
int addition(int a, int b)
{
int result;
result = a + b;
return result;
}
};
int main()
{
DemoAdd d;
int i1 = 10, i2 = 20, res;
res = d.addition(i1, i2);
cout << «Result = « << res << endl;
return 0;
}
Пример 3: Перегрузка функции (1)
В предыдущем примере мы определили функцию «сложение ()», чтобы складывать два целых числа и возвращать вычисленный результат. Теперь в этом примере мы перегрузим функцию «сложение ()», чтобы добавить три целых числа. Таким образом, мы сможем вызывать функцию «сложение ()» с двумя целочисленными аргументами, а также с тремя целочисленными аргументами.
Без функции перегрузки функций нам пришлось бы написать другую функцию с другим именем.
#include <iostream>
using namespace std;
class DemoAdd
{
public:
// First function definition of addition()
int addition(int a, int b)
{
int result;
result = a + b;
return result;
}
// Overloaded version of addition() function
int addition(int a, int b, int c)
{
int result;
result = a + b + c;
return result;
}
};
int main()
{
DemoAdd d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.addition(i1, i2); // addition() with 2 parameters
res2 = d.addition(i1, i2, i3); // addition() with 3 parameters
cout << «Result = « << res1 << endl;
cout << «Result = « << res2 << endl;
return 0;
}
Пример 4: Перегрузка функции (2)
В предыдущих разделах этой статьи вы узнали, что перегрузка функций может выполняться на основе различий в типах параметров. Здесь мы перегрузили функцию «сложение ()» в зависимости от типа данных параметра. В первой версии функции сложения мы добавим две переменные целочисленного типа; а во второй версии мы добавим две переменные типа float.
#include <iostream>
using namespace std;
class DemoAdd
{
public:
// First definition of addition()
int addition(int a, int b)
{
int result;
result = a + b;
return result;
}
// Overloaded function definition
float addition(float f, float g)
{
float result;
result = f + g;
return result;
}
};
int main()
{
DemoAdd d;
int i1 = 10, i2 = 20, res1;
float f1 = 10.5, f2 = 20.7, res2;
res1 = d.addition(i1, i2); // addition(int a, int b) will be called
res2 = d.addition(f1, f2); // addition(float f, flat g) will be called
cout << «Result = « << res1 << endl;
cout << «Result = « << res2 << endl;
return 0;
}
Пример 5: Функциональная перегрузка (3)
В этом примере функция «сложение ()» перегружена из-за различий в последовательности списка параметров. Это еще один способ перегрузить функцию в C ++.
#include <iostream>
using namespace std;
class DemoAdd
{
public:
// First function definition of addition() function
float addition(int a, float b)
{
float result;
result = (float)a + b;
return result;
}
// Overloaded function definition of addition() function
float addition(float a, int b)
{
float result;
result = a + (float)b;
return result;
}
};
int main()
{
DemoAdd d;
int i1 = 10;
float f1 = 10.5, res1, res2;
res1 = d.addition(i1, f1); // addition(int a, float b) will be called
res2 = d.addition(f1, i1); // addition(float a, int b) will be called
cout << «Result = « << res1 << endl;
cout << «Result = « << res2 << endl;
return 0;
}
Заключение
C ++ — универсальный и гибкий язык программирования, широко используемый в различных областях. Этот язык программирования поддерживает полиморфизм как во время компиляции, так и во время выполнения. В этой статье вы узнали, как добиться полиморфизма во время компиляции в C ++ с помощью функции перегрузки функций. Это очень полезная функция C ++, которая помогает программистам писать читаемый код. Это также может быть полезно для написания повторно используемого кода.го кода.
