Rivalry2

HTML Diff

0 added 0 removed

Original 2026-01-01

Modified 2026-03-10

1 <ul><li><a>Определение</a></li>

2 <li><a>Когда использовать процедуру</a></li>

3 <li><a>Синтаксис</a></li>

4 <li><a>Что нельзя перегружать</a></li>

5 <li><a>Способы реализации</a><ul><li><a>Реализация через функцию</a></li>

6 <li><a>Реализация через дружественные функции</a></li>

7 <li><a>Через методы класса</a></li>

8 </ul></li>

9 <li><a>Что можно перегрузить - особенности процесса</a><ul><li><a>Operator =</a></li>

10 <li><a>Ввод и вывод</a></li>

11 <li><a>Унарные операторы</a></li>

12 <li><a>Инкремент и декремент</a></li>

13 <li><a>Индексация</a></li>

14 <li><a>Operator ()</a></li>

15 <li><a>Аллокация и деаллокация</a></li>

16 <li><a>Пользовательские литералы</a></li>

17 </ul></li>

18 </ul><p>Языки программирования используют разнообразные операторы для выполнения операций. В большинстве из них операторы имеют жесткую привязку к типам. Так, в Java сложение с оператором "+" допустимо только для целочисленных значений, чисел с плавающей запятой и строк. Если определить свои классы для математических объектов, разработчику удастся сложить их. Только для вызова соответствующего метода необходимо использовать специальные команды.</p>

19 <p>В C++ подобных ограничений нет. У данного языка программирования поддерживается так называемая перегрузка. Она возможна почти для каждого известного оператора. Это предоставляет целое поле дополнительных возможностей разработчику.</p>

20 <p>Далее предстоит познакомиться с перегрузкой операторов в C++ поближе. Необходимо не только выяснить, что это за операция такая, но и освоить принципы ее реализации. Предложенная информация окажется полезной как программистам-новичкам, так и более опытным разработчикам.</p>

21 <h2>Определение</h2>

22 <p>Перегрузка операторов - это один из способов реализации полиморфизма. Он заключается в возможности одновременного существования в одной и той же области видимости нескольких различных вариантов применения операторов, имеющих одно и то же имя, но различающихся типами параметров, к которым он применяется.</p>

23 <p>Перегрузка (или operator overloading) - операция, позволяющая определить для объектов классов встроенные операторы. Она широко используется разработчиками. Применяется для переопределения действий операторов языка в процессе работы с разнообразными (включая пользовательские) типами. Возможность применения встроенных операторов языка к разным типам данных.</p>

24 <h2>Когда использовать процедуру</h2>

25 <p>В процессе разработки программного обеспечения необходимо запомнить одно правило - перегружать операторы нужно тогда, когда соответствующая процедура имеет смысл: если он очевиден и не несет в себе никаких скрытых "сюрпризов" для программиста.</p>

26 <p>Перегруженные operators должны вести себя так же, как и их "базовые" версии. Исключения допустимы, но лишь тогда, когда они сопровождаются понятными разработчику объяснениями.</p>

27 <p>Примером подобной ситуации могут служить операторы "<<" и ">>" стандартной библиотеки C++ iostream. Они явно ведут себя не как обычный битовый сдвиг.</p>

28 <p>Чтобы лучше понимать, когда лучше применять перегрузку, стоит рассмотреть хороший и плохой примеры реализации соответствующей операции. Наглядным случаем является сложение матриц. Здесь перегрузка сложения является интуитивно понятной. Если грамотно реализовать процедуру, она не будет требовать пояснений.</p>

29 <p>Пример плохой перегрузки сложения - это сложение двух объектов типа "игрок" в игровом проекте. Не совсем понятно, что разработчик имел в виду для этих классов. Результат непонятен, непредсказуем. Что делает соответствующая операция - огромный вопрос. Именно поэтому использование соответствующего оператора - опасное решение.</p>

30 <h2>Синтаксис</h2>

31 <p>Синтаксис рассматриваемой процедуры напоминает определение функции с именем operator@, где @ - это идентификатор оператора. Вот наглядный пример реализации процесса:</p>

32 <p>Обычно операторы (за исключением условных) будут возвращать объект или ссылку на тип, к которому относятся его аргументы.</p>

33 <h2>Что нельзя перегружать</h2>

34 <p>Перегрузка операций предусматривает некоторые особенности и ограничения, о которых должен помнить каждый разработчик. Почти любой operator C++ может быть перегружен. Вот ограничения и нюансы, о которых должен помнить каждый программист:</p>

35 <ul><li>определить новый оператор нельзя (operator**);</li>

36 <li>нельзя перегружать тернарный оператор, доступ ко вложенным именам, доступ к полям, доступ к полям по указателю;</li>

37 <li>рассматриваемая процедура не допускается для операторов каста;</li>

38 <li>нельзя перегружать operator sizeof и operator typeid;</li>

39 <li>количество операндов, их ассоциативность и порядок выполнения определяется стандартной версией;</li>

40 <li>функция operator должна быть или нестатической (функцией-членом), или глобальной свободной функцией, или дружественной;</li>

41 <li>если функция дружественная, бинарный оператор имеет два аргумента, унарный - только один;</li>

42 <li>при работе с нестатической функцией-членом бинарный оператор имеет один аргумент, унарный - вовсе их не имеет;</li>

43 <li>минимум один операнд должен быть пользовательского типа, исключая operator typedef.</li>

44 </ul><p>Только в качестве методов можно перегружать: присваивание, доступ к полям по указателю, вызов функции, доступ по индексу, а также операторы конверсии и управления памятью, доступ к указателю на поле по указателю.</p>

45 <h2>Способы реализации</h2>

46 <p>Перегрузка может быть реализована в C++ несколькими способами. Всего их три:</p>

47 <ul><li>через методы класса;</li>

48 <li>при помощи дружественных функций для класса;</li>

49 <li>посредством обычных функций.</li>

50 </ul><p>Далее каждый вариант будет рассмотрен отдельно. Также предстоит изучить перегружаемые операторы C++ более подробно.</p>

51 <h3>Реализация через функцию</h3>

52 <p>Для использования данного приема необходимо объявить функцию, которая будет переопределять operator тела класса. Соответствующая перегрузка не может обращаться к членам класса напрямую. Воспользоваться подобной операцией можно за счет геттеров.</p>

53 <p>Такой прием рекомендуется использовать вместе операторной перегрузки через дружественные функции тогда, когда для этого нет никакой необходимости в добавлении дополнительных геттеров в класс.</p>

54 <h3>Реализация через дружественные функции</h3>

55 <p>Такой подход напоминает предыдущий вариант. Он отличается от ранее изученной концепции тем, что задействована будет не обычная функция, а дружественная классу. Такой прием позволяет обращаться к членам класса напрямую. Геттеры для этого не нужны.</p>

56 <p>Дружественные функции могут быть определены внутри заданного класса.</p>

57 <p>Выше можно увидеть наглядный пример реализации упомянутого метода в C++.</p>

58 <h3>Через методы класса</h3>

59 <p>Еще один способ операторной перегрузки в C++ - это использование методов класса.</p>

60 <p>В этом случае у функции-метода вместо первого операнда появляется неявный параметр - указатель на объект класса. Выше - наглядный пример того, как это будет выглядеть в программном коде. Теперь можно более подробно рассмотреть операторы, для которых в C++ допустима перегрузка.</p>

61 <h2>Что можно перегрузить - особенности процесса</h2>

62 <p>Далее будут представлены operators, которые можно перегружать. Каждый из них поддерживает характерную семантику (ожидаемое поведение) и типичные способы объявления/реализации.</p>

63 <p>В первом приведенном примере X - это пользовательский тип, для которого будет реализован operator. T - необязательный тип, пользовательский или встроенный. В качестве параметров бинарного оператора выступают lhs и rhs. Если operator объявляется в качестве метода класса, он получит префикс x::.</p>

64 <h3>Operator =</h3>

65 <p>Operator = - это присваивание. Его семантика:</p>

66 <p>a = b</p>

67 <p>Соответствующая запись указывает на то, что значение/состояние b будет передано a. В процессе реализации возвращается ссылка на a. За счет этого приема можно создавать цепочки вроде c = a = b.</p>

68 <p>Operator = определяется справа налево. Он правоассоциативен в отличие от большинства других операторов C++. Это значит, что a = b = c означает a = (b = c).</p>

69 <p>Типичным объявлением копирования является запись: X& X:: operator = (X const& rhs).</p>

70 <p>Перемещения, начиная с C++ 11, имеют семантику присваивания a = temporary(). Значение или состояние правой величины присваивается a за счет перемещения содержимого. На a будет возвращаться ссылка.</p>

71 <h3>Ввод и вывод</h3>

72 <p>Operator << может перегружаться, чтобы добиться более удобного вывода сложных структур в поток вывода.</p>

73 <p>Выше - наглядный пример реализации соответствующей операции. аналогичным образом можно перегрузить operator >>. В этом случае вместо std:: ostream необходимо использовать std::istream.</p>

74 <h3>Унарные операторы</h3>

75 <p>В случае с унарными operators функция переопределения будет принимать на выход только один операнд. Operator + чаще всего ничего не делает, поэтому на практике он почти не используется. Operator - осуществляет возврат аргумента с противоположным знаком.</p>

76 <p>Из-за того, что функция перегрузки принимает только один операнд на вход, рекомендуется осуществлять рассматриваемую операцию посредством метода класса. Выше представлен наглядный пример реализации соответствующего приема.</p>

77 <p>Метод должен быть объявлен в качестве константного. Это необходимо из-за того, что объект класса не меняется, а возвращается новый экземпляр класса.</p>

78 <h3>Инкремент и декремент</h3>

79 <p>Operator ++ (инкремент) и operator - (декремент) предусматривают две версии:</p>

80 <ul><li>постфиксную;</li>

81 <li>префиксную.</li>

82 </ul><p>При перегрузке операторов необходимо различать соответствующие формы инкремента и декремента. Для этого у постфиксных версий имеется так называемый фиктивный параметр типа int. При его наличии компилятор будет понимать, что осуществляется перегрузка постфиксной версии. Если фиктивный параметр отсутствует, целесообразно говорить о работе с префиксной версией.</p>

83 <p>Operator префиксной версии будут возвращать объект после того, как он был увеличен или уменьшен. В постфиксной интерпретации это происходит до уменьшения/увеличения. Из-за данной особенности в необходимо использовать в постфиксной версии временный объект. Он отвечает за возврат значения до его корректировки.</p>

84 <p>Соответствующее явление также приводит к тому, что при возврате невозможно использовать ссылки. Это вызвано уничтожением временного объекта при осуществлении выхода из функции. В постфиксной версии возвращаемое значение - это объект класса. Он дает меньшую эффективность.</p>

85 <h3>Индексация</h3>

86 <p>Еще один вариант переопределения функции в C++ - это работа с индексацией. Ниже приведен пример реализации соответствующей операции:</p>

87 <p>Для константных объектов, когда нельзя корректировать их содержимое, допустимо использовать константную версию функции.</p>

88 <p>При перегрузке индексации допустимо использование проверки передаваемого индекса на факт корректности. В качестве индекса может выступать целое число или любой другой тип данных: string, double и так далее.</p>

89 <h3>Operator ()</h3>

90 <p>Operator () в C++ используется не для изменения объекта, а для его дальнейшего использования в качестве функции. Этот элемент разработки не имеет ограничений на параметры. Подразумевается их количество и типы. Перегрузка оператора осуществляется в качестве метода класса.</p>

91 <p>Типичным примером объявления может служить запись типа: Foo X::operator() (Bar br, Baz const& bz).</p>

92 <h3>Аллокация и деаллокация</h3>

93 <p>Operators new new[] delete delete[] тоже поддерживают возможность переопределения. Они способны принимать любое количество аргументов. Операторы new new[] в качестве первого аргумента принимают аргумент типа sgt::size_t, а возвращать значение типа void *. Operators delete delete[] принимают первым void * и ничего не возвращать. Соответствующие операции могут быть перегружены как функции, а также для определенных классов.</p>

94 <p>Выше можно увидеть наглядный пример реализации соответствующей операции.</p>

95 <h3>Пользовательские литералы</h3>

96 <p>После появления C++ 11 версии язык получил так называемые пользовательские литералы. Такие литералы будут вести себя как обычные функции. Они могут обладать квалификатором inline или constexpr. Рекомендуется начинать литерал с символа нижнего подчеркивания. Это необходимо для того, чтобы исключить коллизию с будущими стандартами.</p>

97 <p>Пользовательские литералы при перегрузке операторов могут принимать только один тип:</p>

98 <ul><li>const char *;</li>

99 <li>unsigned long long int;</li>

100 <li>wchar_t;</li>

101 <li>char;</li>

102 <li>long double;</li>

103 <li>char16_t;</li>

104 <li>char32_t.</li>

105 </ul><p>Достаточно осуществить перегрузку литерала только для типа const char *. Если подходящего кандидата система не нашла, будет произведен вызов оператора с соответствующим типом. Вот наглядный пример преобразования миль в километры при помощи изучаемого процесса:</p>

106 <p>При перегрузке операторов строковые литералы принимают вторым аргументом std::size_t, а первым, один из:</p>

107 <ul><li>const char32_t;</li>

108 <li>const wchar_t;</li>

109 <li>const char16_t;</li>

110 <li>const char *.</li>

111 </ul><p>Строковые литералы применяются к записям, которые оформлены двойными кавычками.</p>

112 <p>В C++ имеется встроенный префиксный строковый литерал R. Он воспринимает все символы, написанные в кавычках, как обычные. R не интерпретирует отдельно взятые последовательности в качестве специальных символов. В качестве примера можно взять команду std::cout << R’’(Hello!\n)’’. Она выведет на экран запись Hello!\n.</p>

113 <p>Чтобы лучше знать C++, рекомендуется пройти <a>дистанционные компьютерные курсы</a>.</p>

114