- •Предисловие
- •1.1. Общие сведения о программах, лексемах и алфавите языка
- •1.3. Идентификаторы и служебные слова
- •2. Константы: целые, вещественные (с плавающей точкой), перечислимые, символьные (литерные), строковые (строки или литерные строки)
- •3. Операции. Знаки операций. Унарные, бинарные и тернарные операции. Приоритеты операций.
- •3.1 Знаки операций
- •3.2 Унарные операции
- •3.3 Бинарные операции.
- •3.4 Приоритеты операций
- •4. Переменные. Определения и описания. Спецификатор typedef.
- •4.1 Переменные. Определения и описания.
- •4.2 Класс памяти
- •5. Базовые и производные типы данных. Массивы. Указатели, ссылки и адреса. Структуры. Поля битов. Объединения
- •5.1 Массивы
- •5.2 Указатели, ссылки и адреса объектов
- •5.3 Структуры
- •5.3 Поля битов
- •5.4 Объединения
- •6. Операторы
- •6.1 Оператор выражение
- •6.2 Пустой оператор
- •6.3 Составной оператор
- •6.4 Оператор if
- •If (выражение) оператор-1; [else оператор-2;]
- •6.5 Оператор switch
- •6.6 Оператор break
- •6.7 Оператор for
- •6.8 Оператор while
- •6.8 Оператор do while
- •6.9 Оператор continue
- •6.10 Оператор return
- •6.11 Оператор goto
- •7. Функции
- •7.1 Определения, описания и вызовы функций
- •7.2 Начальные (умалчиваемые) значения параметров.
- •7.3 Функции с переменным количеством параметров
- •7.4 Перегрузка функций.
- •7.5 Ссылки и параметры-ссылки.
- •7.6 Шаблоны функций.
- •8. Технологии программирования.
- •8.1 Введение.
- •8.2 Модульное программирование.
- •8.3 Нисходящее программирование.
- •8.4 Структурное программирование.
- •8.5 Понятия объекта, класса объектов.
- •8.6 Основные понятия объектно-ориентированного программирования: инкапсуляция, наследование и полиморфизм.
- •9.1 Тип данных - класс.
- •9.2 Доступность компонентов класса
- •9.3 Конструктор и деструктор
- •9.4 Компоненты-данные и компоненты-функции. Статические и константные компоненты класса
- •10. Указатели на компоненты класса
- •10.1 Указатели на компоненты- данные.
- •10.2 Указатели на компоненты- функции.
- •10.3 Указатель this
- •11. Друзья классов
- •11.1 Дружественная функция
- •11.2 Дружественный класс
- •12. Наследование
- •12.1 Определение производного класса.
- •12.2 Конструкторы и деструкторы производных классов
- •13. Полиморфизм
- •13.1 Виртуальные функции.
- •13.2 Абстрактные классы
- •14. Шаблоны классов
- •15. Перегрузка операций
- •15.1 Общие сведения о перегрузке стандартных операций
- •15.2 Перегрузка унарных операций
- •15.3 Перегрузка бинарных операций
- •15.5 Перегрузка операции вызова функции
- •15.6 Перегрузка операции присваивания
- •15.7 Основные правила перегрузки операций.
- •16. Обработка исключительных ситуаций
- •16.1 Операторы try, throw, catch
- •16.2 Универсальный обработчик исключений
- •17. Структура Windows-приложения
- •17.2 Структура каркасного Windows-приложения
- •17.3 Главная функция WinMain()
- •17.4 Сообщения Windows
- •17.5 Класс окна. Регистрация и его характеристики
- •17.6 Создание и показ окна
- •17.7 Цикл обработки сообщений
- •17.8 Оконная функция
- •17.9 Завершение выполнения приложения
- •18. Препроцессор
- •18.1 Общие пpеобpазования
- •18.2 Директивы Препроцессора
- •18.3 Подключаемые файлы
- •18.4. Директива '#include'.
- •18.5 Однократно подключаемые файлы
- •18.6 Макросы
- •18.7 Стрингификация
- •18.8 Объединение
- •18.9 Удаление макросов
- •18.10 Условия
- •19. Разработка Windows приложений с использованием библиотеки классов mfc (microsoft foundation class library)
- •19.1 Некоторые сведения о программировании Windows-приложений
- •19.2 Преимущества использования mfc
- •19.4 Библиотека mfc
- •20. Простейшие mfc-приложения
- •20.1 Приложение без главного окна
- •20.2 Приложение с главным окном
- •20.3 Обработка окном сообщений
15.7 Основные правила перегрузки операций.
Вводить собственные обозначения для операций, не совпадающие со стандартными операциями языка С++ , нельзя.
Не все операции языка С++ могут быть перегружены. Нельзя перегрузить следующие операции:
. – прямой выбор компонента,
.* – обращение к компоненту через указатель на него,
?: – условная операция,
:: – операция указания области видимости,
sizeof’ – вычисление размера
, – операция последовательного вычисления,
#, ## – препроцессорные операции.
Каждая операция, заданная в языке, имеет определенное число операндов, свой приоритет и ассоциативность. Все эти правила, установленные для операций в языке, сохраняются и для ее перегрузки, т.е. изменить их нельзя.
Любая унарная операция определяется двумя способами: либо как компонентная функция без параметров, либо как глобальная (возможно дружественная) функция с одним параметром. Выражениеz означает в первом случае вызов z.operator(), во втором- вызов operator(z).
Любая бинарная операция определяется также двумя способами: либо как компонентная функция с одним параметром, либо как глобальная (возможно дружественная) функция с двумя параметрами. В первом случае xy означает вызов x.operator(y), во втором – вызов operator(x,y).
Перегруженная операция не может иметь аргументы (операнды), заданные по умолчанию.
В языке С++ установлена идентичность некоторых операций, например, ++z – это тоже, что и z+=1. Эта идентичность теряется для перегруженных операций.
Функцию operator можно вызвать по ее имени, например, z=operator*(x,y) или z=x.operator*(y). В первом случае вызывается глобальная функция, во втором – компонентная функция класса Х , и х – это объект класса Х. Однако, чаще всего функция operator вызывается косвенно, например, z=x*y
За исключением перегрузки операций new и delete функция operator должна быть либо нестатической компонентной функцией, либо иметь как минимум один аргумент (операнд) типа “класс” или “ссылка на класс” (если это глобальная функция).
Операции ‘=’, ‘[]’, ‘–>’ можно перегружать только с помощью нестатической компонентной функции operator. Это гарантирует, что первыми операндами будут леводопустимые выражения.
Операция ‘[]’ рассматривается как бинарная. Пусть а – объект класса А, в котором перегружена операция ‘[]’. Тогда выражение a[i] интерпретируется как a.operator[](i).
Операция ‘()’ вызова функции рассматривается как бинарная. Пусть а – объект класса А, в котором перегружена операция ‘()’. Тогда выражение a(x1,x2,x3,x4) интерпретируется как a.operator()(x1,x2,x3,x4).
Операция ‘–>’ доступа к компоненту класса через указатель на объект этого класса рассматривается как унарная. Пусть а – объект класса А, в котором перегружена операция ‘–>’. Тогда выражение a–>m интерпретируется как (a.operator–>())–>m. Это означает, что функция operator–>() должна возвращать указатель на класс А, или объект класса А, или ссылку на класс А.
Перегрузка операций ‘++’ и ‘--‘, записываемых после операнда (z++, z--), отличается добавлением в функцию operator фиктивного параметра int, который используется только как признак отличия операций z++ и z-- от операций ++z и --z.
Глобальные операции new можно перегрузить и в общем случае они могут не иметь аргументов (операндов) типа “класс”. В результате разрешается иметь несколько глобальных операций new, которые различаются путем изменения числа и (или) типов аргументов.
Глобальные операции delete не могут быть перегружены. Их можно перегрузить только по отношению к классу.
Заданные в самом языке глобальные операции new и delete можно изменить, т.е. заменить версию, заданную в языке по умолчанию, на свою версию.
Локальные функции operatornew() иoperatordelete() являются статическими компонентами класса, в котором они определены, независимо от того, использовался или нет спецификаторstatic(это, в частности, означает, что они не могут быть виртуальными).
Для правильного освобождения динамической памяти под базовый и производный объекты следует использовать виртуальный деструктор.
Если для класса Х операция “=” не была перегружена явно и xиy- это объекты класса Х, то выражениеx=yзадает по умолчанию побайтовое копирование данных объектаyв данные объектаx.
Функция operator вида operator type() без возвращаемого значения, определенная в классе А, задает преобразование типа А к типу type.
За исключением операции присваивания ‘=’ все операции, перегруженные в классе Х, наследуются в любом производном классе Y.
Пусть Х – базовый класс, Y – производный класс. Тогда локально перегруженная операция для класса Х может быть далее повторно перегружена в классе Y.