3.8. Основные правила перегрузки операций

Привет, сегодня поговорим про основные правила перегрузки операций, обещаю рассказать все что знаю. Для того чтобы лучше понимать что такое основные правила перегрузки операций , настоятельно рекомендую прочитать все из категории С++ (C plus plus).

1) Вводить собственные обозначения для операций, не совпадающие со стандартными операциями языка С++ , нельзя.

2) Не все операции языка С++ могут быть перегружены. Нельзя перегрузить следующие операции:

‘.’         – прямой выбор компонента,

‘.*’       – обращение к компоненту через указатель на него,

‘?:’       – условная операция,

‘::’        – операция указания области видимости,

‘sizeof’,

‘#’, ‘##’– препроцессорные операции.

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

4)  Любая унарная операция Å определяется двумя способами: либо как компонентная функция без параметров, либо как глобальная (возможно дружественная) функция с одним параметром. Выражение Åz означает в первом случае вызов z.operatorÅ(), во втором- вызов operatorÅ(z).

5) Любая бинарная операция Å определяется также двумя способами: либо как компонентная функция с одним параметром, либо как глобальная (возможно дружественная) функция с двумя параметрами. В первом случае xÅy означает вызовx.operatorÅ(y), во втором – вызов operatorÅ(x,y).

6) Перегруженная операция не может иметь аргументы (операнды), заданные по умолчанию.

7) В языке С++ установлена идентичность некоторых операций, например, ++z – это тоже, что и z+=1. Эта идентичность теряется для перегруженных операций.

8) Функцию operator можно вызвать по ее имени, например, z=operator*(x,y) илиz=x.operator*(y). Об этом говорит сайт https://intellect.icu . В первом случае вызывается глобальная функция, во втором – компонентная функция класса Х , и х – это объект класса Х. Однако, чаще всего функция operator вызывается косвенно, например, z=x*y

9) За исключением  перегрузки операций new и delete функция operator должна быть либо нестатической компонентной функцией, либо иметь как минимум один аргумент (операнд) типа “класс” или “ссылка на класс” (если это глобальная функция).

10) Операции ‘=’, ‘[]’, ‘–>’ можно перегружать только с помощью нестатической компонентной функции operatorÅ. Это гарантирует, что первыми операндами будут леводопустимые выражения.

11) Операция ‘[]’ рассматривается как бинарная. Пусть а – объект класса А, в котором перегружена операция ‘[]’. Тогда выражение a[i] интерпретируется какa.operator[](i).

12) Операция ‘()’ вызова функции рассматривается как бинарная. Пусть а – объект класса А, в котором перегружена операция ‘()’. Тогда выражение a(x1,x2,x3,x4)интерпретируется как a.operator()(x1,x2,x3,x4).

13) Операция ‘–>’ доступа к компоненту класса через указатель на объект этого класса рассматривается как унарная. Пусть а – объект класса А, в котором перегружена операция ‘–>’. Тогда выражение a–>m интерпретируется как(a.operator–>())–>m. Это означает, что функция operator–>() должна возвращать указатель на класс А, или объект класса А, или ссылку на класс А.

14) Перегрузка операций ‘++’ и ‘--‘, записываемых после операнда (z++, z--), отличается добавлением в функцию operator фиктивного параметра int, который используется только как признак отличия операций z++ и z-- от операций ++z и --z.

15) Глобальные операции new можно перегрузить и в общем случае они могут не иметь аргументов (операндов) типа “класс”. В результате разрешается иметь несколько глобальных операций new, которые различаются путем изменения числа и (или) типов аргументов.

16) Глобальные операции delete не могут быть перегружены. Их можно перегрузить только по отношению к классу.

17) Заданные в самом языке глобальные операции new и delete можно изменить, т.е. заменить версию, заданную в языке по умолчанию, на свою версию.

18) Локальные функции operator new() и operator delete() являются статическими компонентами класса, в котором они определены, независимо от того, использовался или нет спецификатор static (это, в частности, означает, что они не могут быть виртуальными).

19) Для правильного освобождения динамической памяти под базовый и производный объекты следует использовать виртуальный деструктор.

20) Если для класса Х операция “=” не была перегружена явно и x и y - это объекты класса Х, то выражение x=y задает по умолчанию побайтовое копирование данных объекта y в данные объекта x.

21) Функция operator вида operator type() без возвращаемого значения, определенная в классе А, задает преобразование типа А к типу type.

22) За исключением операции присваивания ‘=’ все операции, перегруженные в классе Х, наследуются  в любом производном классе Y.

23) Пусть Х – базовый класс, Y – производный класс. Тогда локально перегруженная операция для класса Х может быть далее повторно перегружена в классе Y.

В общем, мой друг ты одолел чтение этой статьи об основные правила перегрузки операций. Работы впереди у тебя будет много. Смело пиши комментарии, развивайся и счастье окажется в твоих руках. Надеюсь, что теперь ты понял что такое основные правила перегрузки операций и для чего все это нужно, а если не понял, или есть замечания, то не стесняйся, пиши или спрашивай в комментариях, с удовольствием отвечу. Для того чтобы глубже понять настоятельно рекомендую изучить всю информацию из категории С++ (C plus plus)