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