Вариант №4. Класс, как настройка над стандартным типом.
virtual returnType functionName(<список параметров>);
};
class className2 : public className1
{
// функции-элементы
virtual returnType functionName(<список параметров>);
};
Правило виртуальной функции гласит:"Виртуальная однажды - виртуальна всегда".
Это означает следующее. Если объявить функцию как виртуальную в некотором классе, то в классах-потомках, переопределяющих эту функцию, она также будет виртуальной, но только если она имеет тот же список параметров. Если переопределенная функция в классе-потомке имеет другой список параметров, то ее версия из базового класса будет недоступна классу-потомку (и всем его потомкам). Это может показаться неудобным, но только на первый взгляд. Правило это справедливо и для всех языков объектно-ориентированного программирования, поддерживающих виртуальные функции, но не допускающих перегрузку функций. В С++ положение несколько иное. Программист может объявлять невиртуальные перегруженные функции, совпадающие по имени с виртуальными функциями, но имеющие другой список параметров. И, кроме того, программист не может наследовать невиртуальные функции, имя которых совпадает с виртуальными функциями. Дружественные классы и функции
В С++ функции-элементы имеют доступ ко всем данным-элементам своего класса. Кроме этого, С++ предусматривает такую возможность еще и для дружественных функций. Объявление дружественной функции производится в объявлении класса и начинается с ключевого слова friend. Кроме наличия спецификатора friend, объявление дружественной функции совпадает с объявлением функции-элемента, однако прямого доступа к классу дружественная функция не имеет, поскольку для этого необходим скрытый указатель this, который ей недоступен. Но если передать такой функции указатель на объект дружественного класса, функция будет иметь доступ к его элементам. Когда дружественная функция определяется вне объявления дружественного ей класса, не нужно в определении указывать имя класса. Дружественной называется обычная функция, которой открыт доступ ко всем элементам-данным одного или нескольких классов.
Общий вид (синтаксис) объявления дружественной функции следующий3:
class className
{
public:
className();
// другие конструкторы
friend returnType friendFunction(<список параметров>);
};
5. Перегрузка операций
Программист может определять смысл операций при их применении к объектам определенного класса. Кроме арифметических, можно определять еще и логические операции, операции сравнения, вызова () и индексирования [], а также можно переопределять присваивание и инициализацию. Можно определить явное и неявное преобразование между определяемыми пользователем и основными типами. Часто программы работают с объектами, которые являются конкретными представлениями абстрактных понятий. Например, тип данных int в C++ вместе с операциями +, -, *, / и т.д. предоставляет реализацию (ограниченную) математического понятия целых чисел. Такие понятия обычно включают в себя множество операций, которые кратко, удобно и привычно представляют основные действия над объектами. К сожалению, язык программирования может непосредственно поддерживать лишь очень малое число таких понятий. Например, такие понятия, как комплексная арифметика, матричная алгебра, логические сигналы и строки не получили прямой поддержки в C++. Классы дают средство спецификации в C++ представления неэлементарных объектов вместе с множеством действий, которые могут над этими объектами выполняться. Иногда определение того, как действуют операции на объекты классов, позволяет программисту обеспечить более общепринятую и удобную запись для манипуляции объектами классов, чем та, которую можно достичь используя лишь основную функциональную запись.
1.1. Функции Операции
Можно описывать функции, определяющие значения следующих операций:
+ - * / % ^ & | ~ !
= <> += -= *= /= %= ^= &=
|= <<>> >>= <<= !="<=">= &&
|| ++ -- [] () new delete
Последние четыре - это индексирование, вызов функции, выделение свободной памяти и освобождение свободной памяти. Изменить приоритеты перечисленных операций невозможно, как невозможно изменить и синтаксис выражений. Нельзя, например, определить унарную операцию % или бинарную !. Невозможно определить новые лексические символы операций, но в тех случаях, когда множество операций недостаточно, можно использовать запись вызова функции. Например, не **, а pow(). Эти ограничения могут показаться драконовскими, но более гибкие правила могут очень легко привести к неоднозначностям. Имя функции операции есть ключевое слово operator (то есть, операция), за которым следует сама операция, например, operator<<. Функция операция описывается и может вызываться так же, как любая другая функция. Использование операции это лишь сокращенная запись явного вызова функции операции.
1.1.1. Бинарные и Унарные Операции
Бинарная операция может быть определена или как функция член, получающая один параметр, или как функция друг, получающая два параметра. Таким образом, для любой бинарной операции @
[email protected] может интерпретироваться или как
[email protected](bb), или как
[email protected](aa,bb). Если определены обе, то
[email protected] является ошибкой. Унарная операция, префиксная или постфиксная, может быть определена или как функция член, не получающая параметров, или как функция друг, получающая один параметр. Таким образом, для любой унарной операции @
[email protected] или @aa может интерпретироваться или как
[email protected](), или как
[email protected](aa). Если определена и то, и другое, то и
[email protected] и @aa являются ошибками. Рассмотрим следующие примеры:
class X {
// друзья
friend X operator-(X); // унарный минус
friend X operator-(X,X); // бинарный минус
friend X operator-(); // ошибка: нет операндов
friend X operator-(X,X,X); // ошибка: тернарная
// члены (с неявным первым параметром: this)
X* operator&(); // унарное & (взятие адреса)
X operator&(X); // бинарное & (операция И)
X operator&(X,X); // ошибка: тернарное
};
Когда операции ++ и -- перегружены, префиксное использование и постфиксное различить невозможно.
1.1.2. Предопределенные значения операций
Относительно смысла операций, определяемых пользователем, не делается никаких предположений. В частности, поскольку не предполагается, что перегруженное = реализует присваивание ее первому операнду, не делается никакой проверки, чтобы удостовериться, является ли этот операнд lvalue. Значения некоторых встроенный операций определены как равносильные определенным комбинациям других операций над теми же аргументами. Например, если a является int, то ++a означает a+=1, что в свою очередь означает a=a+1. Такие соотношения для определенных пользователем операций не выполняются, если только не случилось так, что пользователь сам определил их таким образом. Например, определение operator+=() для типа complex не может быть выведено из определений complex::operator+() и complex::operator=().
1.1.3. Операции и определяемые пользователем типы
Функция операция должна или быть членом, или получать в качестве параметра по меньшей мере один объект класса (функциям, которые переопределяют операции new и delete, это делать необязательно). Это правило гарантирует, что пользователь не может изменить смысл никакого выражения, не включающего в себя определенного пользователем типа. В частности, невозможно определить функцию, которая действует исключительно на указатели. Функция операция, первым параметром которой предполагается основной тип, не может быть функцией членом. Рассмотрим, например, сложение комплексной переменной aa с целым 2: aa+2, при подходящим образом описанной функции члене, может быть проинтерпретировано как aa.operator+(2), но с 2+aa это не может быть сделано, потому что нет такого класса int, для которого можно было бы определить + так, чтобы это означало 2.operator+(aa). Даже если бы такой тип был, то для того, чтобы обработать и 2+aa и aa+2, понадобилось бы две различных функции члена. Так как компилятор не знает смысла +, определенного пользователем, то не может предполагать, что он коммутативен, и интерпретировать 2+aa как aa+2. С этим примером могут легко справиться функции друзья.4
Все функции операции по определению перегружены. Функция операция задает новый смысл операции в дополнение к встроенному определению, и может существовать несколько функций операций с одним и тем же именем, если в типах их параметров имеются отличия, различимые для компилятора, чтобы он мог различать их при обращении.
1.1.4. Операции Преобразования
Применение определяемых операций преобразования - это типы, которые предоставляют нестандартные представления чисел (арифметика по основанию 100, арифметика с фиксированной точкой, двоично-десятичное представление и т.п.). При этом обычно переопределяются такие операции,
как + и *.
Функции преобразования оказываются особенно полезными для работы со структурами данных, когда чтение (реализованное посредством операции преобразования) тривиально, в то время как присваивание и инициализация заметно более сложны.
Типы istream и ostream опираются на функцию преобразования, чтобы сделать возможными такие операторы, как while (cin>>x) cout<>x выше возвращает
istream&. Это значение неявно преобразуется к значению, которое указывает состояние cin, а уже это значение может проверяться оператором while
6. Программный код
#include <iostream>
using namespace std;
class SuperInt{ //класс-надстройка над int
private:
long value;
public:
SuperInt (int intValue){ //конструктор
value = intValue;
}
SuperInt(){ //конструктор с дефолтным значением
value = 0;
}
long operator +(long addValue){ //перегрузка сложения
return value + addValue;
}
long operator -(long subValue){ //перегрузка вычитания
return value - subValue;
}
long operator *(long mulValue){ //перегрузка умножения
return value * mulValue;
}
class Zero{}; //класс для пробрасывания исключений деления на 0
long operator /(long divValue){ //деление нацело
try{
if (divValue != 0)
return value / divValue;
else
throw Zero(); //пробросить исключение
}
catch(Zero &e){
cout << "ERROR: Division By Zero" << endl; //выдать ошибку
}
return 0;
}
long operator %(long divValue){ //остаток от деления
try{
if (divValue != 0)
return value % divValue;
else
throw Zero();
}
catch(Zero &e){
cout << "ERROR: Division By Zero" << endl;
}
return 0;
}
long operator ++(){ //перегрузка ++
return value++;
}
long operator --(){ //перегрузка --
return value--;
}
friend std::istream& operator>>(std::istream& cin,SuperInt& superInt){ //потоковый ввод