// Вычитание одной точки из другой дает меньшую точку?
Console.WriteLine("ptOne – ptTwo: {0} ", ptOne – ptTwo);
Console.ReadLine();
}
Чтобы позволить пользовательскому типу по-своему отвечать на встроенные операции, в C# предлагается ключевое слово operator, которое можно использовать только со статическими методами. Перегруженной бинарной операции (такой, как + или -) на вход подаются два аргумента, которые имеют тип определяющего класса (в данном примере это Point), как показывает следующий программный код.
// Более 'интеллектуальный' тип Point.
public struct Point {
…
// перегруженная операция +
public static Point operator+(Point p1, Point p2) { return new Point(p1.x + p2.x, p1.y + p2.y); }
// перегруженная операция -
public static Point operator–(Point p1, Point p2) { return new Point(p1.x – p2.x, p1.y – p2.y); }
}
По логике операция + должна просто возвратить совершенно новый объект Point, полученный в результате суммирования соответствующих полей входных параметров Point. Поэтому, когда вы пишете pt1 + pt2, можете представлять себе следующий скрытый вызов статического метода операции +.
// р3 = Point.операция+(p1, р2)
р3 = p1 + р2;
Точно так же p2 – p2 отображается в следующее.
// р3 = Point.операция-(p1, р2)
р3 = p1 – p2;
Операции += и -=
Если вы изучаете C#, уже имея опыт использования C++, то можете обратить внимание на отсутствие возможности перегрузки операторных сокращений, включающих операцию присваивания (+=, -= и т.д.). Не волнуйтесь, в C# операторные сокращения с присваиванием моделируются автоматически, если тип предполагает перегрузку соответствующей бинарной операции. Поэтому, поскольку структура Point уже использует перегрузку операций + и -, вы можете записать следующее.
// Перегрузка бинарных операций автоматически влечет перегрузку
// операторных сокращений с присваиванием.
static void Main(string[] args) {
// Автоматическая перегрузка +=
Point ptThree = new Point(90, 5);
Console.WriteLine("ptThree = {0}", ptThree);
Console.WriteLine("ptThree +=ptTwo: {0}", ptThree += ptTwo);
// Автоматическая перегрузка -=
Point ptFour = new Point(0, 500);
Console.WriteLine("ptFour = {0}", ptFour);
Console.WriteLine("ptFour -= ptThree: {0}", ptFour -= ptThree);
}
Перегрузка унарных операций
В C# также позволяется перегрузка унарных операций, таких как, например, ++ и --. При перегрузке унарной операции вы тоже должны с помощью ключевого слова operator определить статический метод, но в данном случае передается только один параметр, который должен иметь тип, соответствующий определяющему классу или структуре. Например, если добавить в Point следующие перегруженные операции
public struct Point {
…
// Добавление 1 к поступившему Point.
public static Point operator++(Point p1) { return new Point(p1.x+1, p1.y+1); }
// Вычитание 1 от поступившего Point.
public static Point operator--(Point p1) { return new Point(p1.x-1, p1.y-1); }
}
то вы получите возможность увеличивать или уменьшать на единицу значения X и Y объекта Point, как показано ниже.
static void Main(string[] args) {
…
// Применение унарных операций ++ и -- к Point.
Console.WriteLine("++ptFive = {0}", ++ptFive);
Console.WriteLine("--ptFive = {0}", --ptFive);
}
Перегрузка операций проверки на тождественность
Вы можете помнить из материала главы 3, что System.Object.Equals() можно переопределить, чтобы сравнение типов выполнялось на основе значений (а не ссылок). Если вы переопределите Equals() (и связанный с Equals() метод System.Object.GetHashCode()), то будет очень просто задать перегрузку операций проверки на тождественность (== и !=). Для иллюстрации мы рассмотрим обновленный тип Point.
// Такая 'инкарнация' Point задает также перегрузку операций == и !=.
public struct Point {
…
public override bool Equals(object o) {
if (o is Point) {
if (((Point)o).x == this.x && ((Point)о). у == this.y) return true;
}
return false;
}
public override int GetHashCode() { return this.ToString().GetHashCode(); }
// Здесь позволяется перегрузка операций == и !=.
public static bool operator==(Point p1, Point p2) { return p1.Equals(p2); }
public static bool operator!=(Point p1, Point p2) { return!p1.Equals(p2); }
}
Обратите внимание на то, что данная реализация операций == и != просто вызывает переопределенный метод Equals(), который и выполняет основную работу. С учетом этого вы можете теперь использовать свой класс Point так.
// Использование перегруженных операций проверки на тождественность.
static void Main(string[] args) {
…
Console.WriteLine("ptOne == ptTwo: {0}", ptOne == ptTwo);
Console.WriteLine("ptOne != ptTwo: {0}", ptOne != ptTwo);
}
Как видите, здесь два объекта сравниваются с помощью операций == и !=, а не с помощью "менее естественного" вызова Object.Equals(). При использовании перегрузки операций проверки на тождественность для класса имейте в виду, что в C# требуется, чтобы при переопределении операции – обязательно переопределялась и операция != (если вы забудете это сделать, компилятор вам напомнит).
Перегрузка операций сравнения
Из материала главы 7 вы узнали о том, как реализовать интерфейс IComparable, чтобы иметь возможность сравнения подобных объектов. В дополнение к этому для того же класса вы можете использовать перегрузку операций сравнения (‹, ›, ‹= и ›=). Подобно операциям проверки на тождественность, в C# требуется, чтобы при перегрузке ‹ выполнялась и перегрузка ›. Это же касается и операций ‹= и ›=. Если тип Point использует перегрузку операций сравнения, пользователь объекта получает возможность сравнивать объекты Point так, как показано ниже.
// Использование перегруженных операций ‹ и ›.
static void Main(string[] args) {
…
Console.WriteLine("ptOne ‹ ptTwo: {0}", ptOne ‹ ptTwo);
Console.WriteLine("ptOne › ptTwo: {0}", ptOne › ptTwo);
}
В предположении о том, что интерфейс IComparable реализован, перегрузка операций сравнения оказывается тривиальной. Вот как может выглядеть обновленное определение класса.
// Можно сравнивать объекты Point с помощью операций сравнения.
public struct Point: IComparable {
…
public int CompareTo(object obj) {
if (obj is Point) {
Point p = (Point)obj;
if (this.x › p.x && this.y › p.y) return 1;
if (this.x ‹ p.x && this.y ‹ p.y) return -1;
else return 0;
} else throw new ArgumentException();
}
public static bool operator‹(Point p1, Point p2) { return(p1.CompareTo(р2) ‹ 0); }
public static bool operator›(Point p1, Point p2) { return(p1.CompareTo(p2) › 0); }
public static bool operator‹=(Point p1, Point p2) { return(p1.CompareTo(p2) ‹= 0); }
public statiс bool operator›=(Point p1, Point p2) { return(p1.CompareTo(p2) ›= 0); }
}
Внутреннее представление перегруженных операций
Подобно любому элементу программы C#, перегруженные операции представляются специальными элементами синтаксиса CIL. Откройте, например, компоновочный блок OverloadedOps.exe с помощью ildasm.exe. Как показано на рис. 9.1, перегруженные операции внутри блока представляются скрытыми методами (это, например, op_Addition(), oр_Subtraction(), op_Equality() и т.д.).
Теперь, если рассмотреть CIL-инструкции для метода op_Addition, то вы обнаружите, что csc.exe добавляет в метод ключевое слово specialname.
.method public hidebysig specialname static valuetype OverloadedOps.Point op_Addition(valuetype OverloadedsOps.Point p1, valuetype OverloadedOps.Point p2) cil managed {
…
}
Рис. 9.1. В терминах CIL перегруженные операции отображаются в скрытые методы
Итак, любая операция, допускающая перегрузку, сводится в терминах CIL к специальному именованному методу. В табл. 9.2 раскрывается соответствие имен типичных операций C# и методов CIL.
Таблица 9.2. Соответствие имен операций C# и методов CIL
Внутренняя операция C# Представление CIL
–- op_Decrement() ++ op_Increment() + op_Addition() – op_Subtraction() * op_Multiply() / op_Division() == op_Equality() › op_GreaterThan() ‹ op_LessThan() != op_Inequality() ›= op_GreaterThanOrEqual() ‹= op_LessThanOrEqual() –= op_SubtractionAssignment() += op_AdditionAssignment()
Использование перегруженных операций в языках, не поддерживающих перегрузку операций
