Перегрузка в C ++

C ++ не позволяет функции, которая складывает два целых числа и возвращает целое число, добавлять два числа с плавающей запятой и возвращать одно число с плавающей запятой. Представьте, что есть функция для сложения двух целых чисел и возврата целого числа. Было бы неплохо иметь другую функцию с тем же именем, которая добавляет только два или даже больше числа с плавающей запятой для возврата числа с плавающей запятой? Это называется перегрузкой первой функции.

Арифметические операторы обычно используются для арифметических операций. Разве не хорошо иметь +, соединить две строки? Включение этого называется перегрузкой оператора арифметического сложения для строк.

Оператор инкремента ++ добавляет 1 к int или float. При работе с указателями он не добавляет 1 к указателю. Он заставляет указатель указывать на следующий последовательный объект в памяти. Итератор указывает на следующий объект в связанном списке, но объекты связанного списка находятся в разных местах памяти (не в последовательных регионах). Было бы неплохо перегрузить оператор инкремента для итератора, чтобы увеличивать, но указывать на следующий элемент в связанном списке?

В этой статье объясняется перегрузка в C++. Он разделен на две части: перегрузка функции и перегрузка оператора. Для понимания остальной части статьи необходимо уже иметь базовые знания C ++.

Содержание статьи

Перегрузка функций
Перегрузка оператора
Пример перегрузки оператора класса String
Перегрузка оператора итератора
Заключение

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

Следующая функция добавляет два целых числа и возвращает целое число:

интервал добавления (интервал №1, интервал №2)

int sum = no1 + no2;
сумма возврата;

Прототип этой функции:
int add (int no1, int no2);
Прототип функции в заголовке функции, заканчивающийся точкой с запятой. Следующая функция с тем же именем, но с другим прототипом добавит три числа с плавающей запятой и вернет одно число:
добавление поплавка (поплавок №1, поплавок №2, поплавок №3)

сумма с плавающей запятой = no1 + no2 + no3;
сумма возврата;

Как компилятор различает, какую функцию вызывать, поскольку две или более функций имеют одно и то же имя? Компилятор использует количество аргументов и типы аргументов, чтобы определить, какую функцию вызывать. Список параметров перегруженных функций должен отличаться их количеством и / или типами параметров. Итак, вызов функции,

int sm = добавить (2, 3);

вызовет целочисленную функцию, а вызов функции,

float sme = add (2.3, 3.4, 2.0);

вызовет функцию с плавающей запятой. Примечание: бывают ситуации, когда компилятор отклоняет перегруженную функцию, когда количество аргументов одинаковое, но разных типов! - Причина: - см. Позже.

Следующая программа приводит в действие указанные выше сегменты кода:

#включать
используя пространство имен std;
интервал добавления (интервал №1, интервал №2)

int sum = no1 + no2;
сумма возврата;

добавление поплавка (поплавок №1, поплавок №2, поплавок №3)

сумма с плавающей запятой = no1 + no2 + no3;
сумма возврата;

int main ()

int sm = добавить (2, 3);
cout<float sme = add (2.3, 3.4, 2.0);
cout<возврат 0;

Результат:
5
7.7

Перегрузка оператора

Арифметические операторы используются для перегрузки операций в типах классов. Итератор - это тип класса. Операторы инкремента и декремента используются для перегрузки операций итератора.

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

В этом разделе представлен пример, где + перегружен для просто разработанного строкового класса, называемого классом пружины. + объединяет литералы двух строковых объектов, возвращая новый объект с объединенными литералами. Объединение двух литералов означает присоединение второго литерала к концу первого литерала.

Теперь в C ++ есть специальная функция-член для всех классов, называемая оператором. Программист может использовать эту специальную функцию для перегрузки операторов, таких как +. Следующая программа показывает перегрузку оператора + для двух строк.

#включать
используя пространство имен std;
классная весна

общественность:
// члены данных
char val [100];
int n;
char concat [100];
// функции-члены
весна (char arr [])

для (int i = 0; i<100; ++i)
val [i] = arr [i];
если (arr [i] == '\ 0')
перерыв;

int i;
для (i = 0; i<100; ++i) if (arr[i] == '\0') break;
п = я;

Spring оператор + (spring & st)
int newLen = n + st.n;
char newStr [newLen + 1];
для (int i = 0; iдля (int i = n; inewStr [newLen] = '\ 0';
spring obj (newStr);
return obj;

;
int main ()

char ch1 [] = "Я тебя ненавижу! "; пружина стр1 (ч1);
char ch2 [] = "Но она любит тебя!"; пружина стр2 (ч2);
char ch3 [] = "один"; пружина стр3 (ч3);
str3 = str1 + str2;
cout<возврат 0;

Значение str1: "Я тебя ненавижу! ". Значение str2: «Но она любит тебя!". Значение str3, то есть str1 + str2, является выходом:

"Ненавижу тебя! Но она любит тебя!"

который является конкатенацией двух строковых литералов. Сами строки представляют собой экземпляры объектов.

Определение операторной функции находится внутри описания (определения) строкового класса. Он начинается с возвращаемого типа «пружина» вместо «строка». Специальное имя "оператор, следуйте за этим". После этого идет символ оператора (подлежащего перегрузке). Затем идет список параметров, который на самом деле является списком операндов. + является бинарным оператором: это означает, что он принимает левый и правый операнды. Однако, согласно спецификации C ++, в списке параметров здесь есть только правильный параметр. Затем идет тело операторной функции, которое имитирует поведение обычного оператора.

Согласно спецификации C ++, определение оператора + принимает только параметр правого операнда, потому что остальная часть описания класса является параметром левого операнда.

В приведенном выше коде только определение функции operator + () связано с перегрузкой +. Остальной код для класса - это обычная кодировка. Внутри этого определения два строковых литерала объединены в массив newStr []. После этого фактически создается новый строковый объект (экземпляр) с использованием аргумента newStr []. В конце определения функции operator + () возвращается вновь созданный объект, имеющий объединенную строку.

В функции main () добавление выполняется с помощью оператора:

str3 = str1 + str2;

Где str1, str2 и str3 - строковые объекты, которые уже были созданы в main (). Выражение «str1 + str2» с его + вызывает функцию-член operator + () в объекте str1. Функция-член operator + () в объекте str1 использует str2 в качестве аргумента и возвращает новый объект с (разработанной) объединенной строкой. Оператор присваивания (=) полного оператора заменяет содержимое (значения переменных) объекта str3 содержимым возвращенного объекта. В функции main () после добавления значение элемента данных str3.val больше не "единица"; это объединенная (добавочная) строка: "Я тебя ненавижу! Но она любит тебя!". Функция-член operator + () в объекте str1 использует строковый литерал своего собственного объекта и строковый литерал своего аргумента str2 для получения объединенного строкового литерала.

Перегрузка оператора итератора

При работе с итератором задействованы как минимум два объекта: связанный список и сам итератор. Фактически задействованы как минимум два класса: класс, из которого создается связанный список, и класс, из которого создается итератор.

Связанный список

Схема для объекта двусвязного списка:

В этом списке три элемента, но их может быть и больше. Три элемента здесь являются элементами целых чисел. Первый имеет значение 14; следующий имеет значение 88; а последний имеет значение 47. Каждый элемент здесь состоит из трех последовательных мест.

Это не похоже на массив, где каждый элемент находится в одном месте, а все элементы массива находятся в последовательных местах. Здесь разные элементы находятся в разных местах в серии памяти, но каждый элемент состоит из трех последовательных мест.

Для каждого элемента среднее расположение содержит значение. В правильном месте находится указатель на следующий элемент. В левом месте находится указатель на предыдущий элемент. Для последнего элемента правильное расположение указывает на теоретический конец списка. Для первого элемента левая позиция указывает на теоретическое начало списка.

В массиве оператор инкремента (++) увеличивает указатель на физически следующее место. В списке элементы не находятся в последовательных областях памяти. Итак, оператор инкремента можно перегрузить, переместить итератор (указатель) с одного элемента на логически следующий элемент. Такая же проекция применяется к оператору декремента (-).

Прямой итератор - это итератор, который при включении указывает на следующий элемент. Обратный итератор - это итератор, который при включении указывает на предыдущий элемент.

Перегрузка ++ ad -

Перегрузка этих операторов производится в описании (определении) класса итератора.

Синтаксис прототипа префикса перегрузки оператора приращения:

ReturnType operator ++ ();

Синтаксис прототипа перегрузки оператора инкремента, postfix, следующий:

ReturnType operator ++ (int);

Синтаксис прототипа перегрузки оператора декремента, префикса, следующий:

Оператор ReturnType - ();

Синтаксис прототипа перегрузки оператора инкремента, postfix, следующий:

Оператор ReturnType - (int);

Заключение

Перегрузка означает придание другому значению функции или оператора. Функции перегружены в той же области. Что отличает перегруженные функции, так это количество и / или типы параметров в их списках параметров. В некоторых случаях, когда количество параметров одинаковое, но с разными типами, компилятор отклоняет перегрузку - см. Ниже. Многие обычные операторы могут быть перегружены в классах, из которых создаются экземпляры объектов. Это делается путем указания типа возвращаемого значения, списка параметров и тела специальной функции с именем operator в описании класса.