Претоварване на функциите на C ++

C ++ е гъвкав език за програмиране с общо предназначение. Този език за програмиране първоначално е създаден от Bjarne Stroustrup, датски компютърен учен, още през 1985 година. C ++ поддържа полиморфизъм, наследяване и др. Тази статия обхваща претоварване на функциите за постигане на полиморфизъм по време на компилация в езика за програмиране C ++.

Какво е функция?

Функцията не е нищо повече от конкретна част от кода, която изпълнява конкретна задача въз основа на предоставените входове и връща исканите резултати на потребителя под формата на изход. Функциите се използват за премахване на повтарящ се код в големи кодови бази.

След като дефинирате функция, можете да я използвате повторно по-късно, или в същата програма, или в друга програма.

Синтаксис на функцията

Функция в C ++ има следния синтаксис:

returnType functionName (параметър_ списък)

..
..
връщане return_value;

ReturnType, параметър_списък и оператор 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 (), add_2 () и т.н.] за всяка вариация. Например може да се наложи да напишете add_1 (), за да добавите две цели числа, add_2 (), за да добавите две плувки и т.н. Както обаче можете да видите по-горе, функцията за претоварване на функцията може да се използва за дефиниране на множество варианти на функцията “addition ()”, като същевременно запазва същото име на функция.

Следните функции не се считат за претоварени, тъй като единствената разлика между тези две е типът на връщане (типът на връщане не се счита за претоварване на функции в 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
използване на пространство от имена std;
клас Дисплей

публично:
показване на празнота ()

Cout << "Hello World!" << endl;

;
int main ()

Дисплей d;
д.дисплей ();
връщане 0;

Пример 2: Функция за просто добавяне

В този пример ще демонстрираме как да дефинираме проста функция “add ()” в C++. Ще дефинираме клас, наречен „DemoAdd“ и публична функция, наречена „add ().”От функцията“ main () ”ще извикаме функцията“ add () ”с помощта на обекта на класа“ DemoAdd ”(d).

В този пример текущата реализация на функцията “add ()” приема само два целочислени параметъра. Това означава, че текущата функция “add ()” може да добавя само две цели числа.

За да добавите три цели числа вместо две, може да бъде дефинирана функция с различно име, като „add_1 ()“. В C ++ функция може да бъде претоварена, което означава, че може да бъде дефинирана друга дефиниция на функцията „add ()“, за да се добавят три цели числа и да се запази същото име, т.е.д., „Добавяне ().”В следващия пример ще разгледаме как да претоварим функцията„ add () ”.

#include
използване на пространство от имена std;
клас DemoAdd

публично:
добавяне на int (int a, int b)

int резултат;
резултат = a + b;
връщане на резултат;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, res;
res = d.добавяне (i1, i2);
Cout << "Result = " << res << endl;
връщане 0;

Пример 3: Претоварване на функцията (1)

В предишния пример дефинирахме функцията “add ()”, за да добавим две цели числа и да върнем изчисления резултат. Сега в този пример ще претоварим функцията “add ()”, за да добавим три цели числа. И така, ще можем да извикаме функцията “add ()” с два цели аргумента, както и три цели числа.

Без функцията за претоварване на функцията ще трябва да напишем друга функция с различно име.

#include
използване на пространство от имена std;
клас DemoAdd

публично:
// Първа дефиниция на функцията за добавяне ()
добавяне на int (int a, int b)

int резултат;
резултат = a + b;
връщане на резултат;

// Претоварена версия на функцията add ()
добавяне на int (int a, int b, int c)

int резултат;
резултат = a + b + c;
връщане на резултат;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, i3 = 30, res1, res2;
res1 = d.добавяне (i1, i2); // добавяне () с 2 параметъра
res2 = d.добавяне (i1, i2, i3); // добавяне () с 3 параметъра
Cout << "Result = " << res1 << endl;
Cout << "Result = " << res2 << endl;
връщане 0;

Пример 4: Претоварване на функцията (2)

В по-ранните раздели на тази статия научихте, че претоварването на функциите може да се извърши въз основа на разликите в типа параметри. Тук сме претоварили функцията “add ()” въз основа на типа данни на параметъра. В първата версия на функцията за добавяне ще добавим две променливи от цяло число; а във втората версия ще добавим две променливи от тип float.

#include
използване на пространство от имена std;
клас DemoAdd

публично:
// Първа дефиниция на добавяне ()
добавяне на int (int a, int b)

int резултат;
резултат = a + b;
връщане на резултат;

// Дефиниция на претоварена функция
добавяне на плувка (плувка f, плувка g)

плаващ резултат;
резултат = f + g;
връщане на резултат;

;
int main ()

DemoAdd d;
int i1 = 10, i2 = 20, res1;
плувка f1 = 10.5, f2 = 20.7, res2;
res1 = d.добавяне (i1, i2); // добавянето (int a, int b) ще бъде извикано
res2 = d.добавяне (f1, f2); // добавяне (float f, flat g) ще бъде извикано
Cout << "Result = " << res1 << endl;
Cout << "Result = " << res2 << endl;
връщане 0;

Пример 5: Претоварване на функцията (3)

В този пример функцията “add ()” е претоварена въз основа на разликите в последователността на списъка с параметри. Това е друг начин за претоварване на функция в C++.

#include
използване на пространство от имена std;
клас DemoAdd

публично:
// Дефиниция на първата функция на функцията add ()
добавяне на плувка (int a, float b)

плаващ резултат;
резултат = (плаващ) a + b;
връщане на резултат;

// Претоварена дефиниция на функция за добавяне () функция
добавяне на плувка (плувка a, int b)

плаващ резултат;
резултат = a + (плаващ) b;
връщане на резултат;

;
int main ()

DemoAdd d;
int i1 = 10;
плувка f1 = 10.5, res1, res2;
res1 = d.добавяне (i1, f1); // добавянето (int a, float b) ще бъде извикано
res2 = d.добавяне (f1, i1); // добавянето (float a, int b) ще бъде извикано
Cout << "Result = " << res1 << endl;
Cout << "Result = " << res2 << endl;
връщане 0;

Заключение

C ++ е универсален и гъвкав език за програмиране, който се използва широко в различни домейни. Този език за програмиране поддържа полиморфизъм както по време на компилация, така и по време на изпълнение. В тази статия научихте как да постигнете полиморфизъм по време на компилация в C ++, като използвате функцията за претоварване на функцията. Това е много полезна функция в C ++, която помага на програмистите да напишат четим код. Също така може да бъде полезно за писане на код за многократна употреба.