Использование перегруженных операций в языках, не поддерживающих перегрузку операций
Понимание того, как перегруженные операции представлены в программном коде CIL интересно не только с академической точки зрения. Чтобы осознать практическую пользу этих знаний, вспомните о том, что возможность перегрузки операций поддерживается не всеми языками, предназначенными для .NET. Как, например, добавить пару типов Point в программу, созданную на языке, не поддерживающем перегрузку операций?
Одним из подходов является создание "нормальных" открытых членов, которые будут решать ту же задачу, что и перегруженные операции. Например, можно добавить в Point методы Add() в Subtract(), которые будут выполнять работу, соответствующую операциям + и -.
// Экспозиция семантики перегруженных операций
// с помощью простых членов-функций.
public struct Point {
// Представление операции + с помощью Add()
public static Point Add(Point p1, Point p2) { return p1 + p2; }
// Представление операции – с помощью Subtract()
public static Point Subtract(Point p1, Paint p2) { return p1 – p2; }
}
С такими модификациями тип Point способен демонстрировать соответствующие функциональные возможности, используя любые подходы, предлагаемые в рамках данного языка. Пользователи C# могут применять операции + и – или же вызывать Add()/Subtract().
// Использование операции + или Add() ,
Console.WriteLine("ptOne + ptTwo: {0} ", ptOne + ptTwo);
Console.WriteLine("Point.Add(ptOne, ptTwo): {0} ", Point.Add(ptOne, ptTwo));
// Использование операции – или Subtract().
Console.WriteLine("ptOne – ptTwo: {0} ", ptOne – ptTwo);
Console.WriteLine("Point.Subtract(ptOne, ptTwo): {0} ", Point.Subtract(ptOne, ptTwo));
Языки, в которых не допускается перегрузка операций, могут использовать только открытые статические методы. В качестве альтернативы можно предложить непосредственный вызов специальных именованных методов, создаваемых компилятором.
Рассмотрим исходный вариант языка программирования VB. NET. При построении консольного приложения VB .NET, ссыпающегося на тип Point, вы можете добавлять или вычитать типы Point, используя "специальные CIL-имена", например:
' Предполагается, что данное приложение VB.NET ' имеет доступ к типу Point.
Module OverLoadedOpClient
Sub Main()
Dim p1 As Point
p1.x = 200
p1.y= 9
Dim p2 As Point
p2.x = 9
p2.y = 983
' He так красиво, как вызов AddPoints(),
' но зато работает.
Dim bigPoint = Point.op_Addition(p1, p2)
Console.WriteLine("Большая точка {0}", bigPoint)
End Sub
End Module
Как видите, языки программирования .NET, не предусматривающие перегрузку операций, способны непосредственно вызывать внутренние методы CIL, как "обычные" методы. Такое решение нельзя назвать слишком "изящным", но оно работает.
Замечание. Текущая версия VB .NET (Visual Basic .NET 2005) перегрузку операций поддерживает. Однако для других (многочисленных) управляемых языков, не поддерживающих перегрузку операций, знание "специальных имен" соответствующих методов CIL может оказаться очень полезным.
Заключительные замечания о перегрузке операций
Вы могли убедиться в том, что C# обеспечивает возможность построения типов, по-своему отвечающих на встроенные всем известные операции. Перед тем как перейти к непосредственной модификации классов для поддержки такого поведения, вы должны убедиться в том, что для операций, которым вы хотите назначить перегрузку, такая перегрузка имеет смысл.
Предположим, например, что вы хотите использовать перегрузку операции умножения для класса Engine (мотор). Что тогда должно означать умножение двух объектов Engine? He понятно. Перегрузка операций, в общем, оказывается полезной только тогда, когда строятся полезные типы. Строки, точки, прямоугольники и шестиугольники являются хорошими объектами для перегрузки операций. А люди, менеджеры, автомобили, наушники и бейсбольные кепки – нет. Если перегруженная операция делает более трудным понимание функциональных возможностей типа пользователем, то лучше перегрузку не использовать. Используйте указанную возможность с умом.
Исходный код. Проект OverloadedOps размещен в подкаталоге, соответствующем главе 9.
Пользовательские преобразования типов
Рассмотрим тему, близко связанную с перегрузкой операций: это пользовательские правила преобразования типов. В начале вашего рассмотрения мы кратко обсудим явные и неявные преобразования числовых данных и соответствующих типов класса.
Преобразования чисел
В случае встроенных числовых типов (sbyte, int, float и т.д.) явное преобразование требуется тогда, когда вы пытаетесь сохранить большее значение в меньшем контейнере, поскольку при этом может происходить потеря данных. По сути, это способ сказать компилятору примерно следующее: "Не беспокойся, я знаю, что делаю!" С другой стороны, неявное преобразование происходит автоматически, когда вы пытаетесь разместить в типе-адресате тип меньших размеров, в результате чего потери данных не происходит.
static void Main() {
int a = 123;
long b = a; // Неявное преобразование из int a long
int с = (int)b; // Явное преобразование из long в int
}
Преобразования типов класса
Как показано в главе 4, типы класса могут быть связаны классическим отношением наследования (отношение "is-a"). В этом случае в C# процесс преобразования позволяет сдвигаться вверх или вниз по иерархии классов. Например, производный класс всегда можно неявно преобразовать в базовый тип. Однако если вы захотите сохранить базовый тип класса в производной переменной, придется выполнить явное преобразование.
// Два связанных типа класса.
class Base{}
class Derived: Base{}
class Program {
static void Main() {
// Неявное преобразование из производного в базовый.
Base myBaseType;
myBaseType = new Derived();
// Для сохранения базовой ссылки в производном типе
// следует выполнить явное преобразование.
Derived myDerivedType = (Derived)myBaseType;
}
}
Здесь явное преобразование работает благодаря тому, что классы Base и Derived связаны классическим отношением наследования. Но что делать в том случае, когда вы хотите связать преобразованием два типа класса, принадлежащие разным иерархиям? Если классы не связаны классическим наследованием, явное преобразование помочь ничем не сможет.
В соответствующем ключе рассмотрим типы, характеризуемые значениями. Предположим, что у нас есть две .NET-структуры с именами Square (квадрат) и Rectangle (прямоугольник). Поскольку структуры не могут использовать классическое наследование, нет и естественного способа взаимного преобразования этих явно связанных типов (в предположении о том, что такое преобразование имеет смысл).
Конечно, проблему можно решить с помощью создания в этих в структурах вспомогательных методов (например, Rectangle.ToSquare()), но в C# можно создавать пользовательские подпрограммы преобразования, позволяющие соответствующим типам по-своему отвечать на операцию (). Так, при правильной конфигурации типа Square вы получите возможность использовать следующий синтаксис для явного преобразования этих типов структуры.
// Превращение прямоугольника в квадрат.
Rectangle rect;
rect.Width = 3;
rect.Height = 10;
Square sq = (Square)rect;
Создание пользовательских подпрограмм преобразования
В C# есть два ключевых слова, explicit и implicit, предназначенные для управления тем, как типы должны отвечать на попытки преобразования. Предположим, что у нас есть следующие определения структур.
public struct Rectangle {
// Открыты для простоты,
// но ничто не мешает инкапсулировать их в виде свойств.
public int Width, Height;
public void Draw() { Console.WriteLine("Отображение прямоугольника."); }
public override string ToString() {
return string.Format("[Ширина = {0}; Высота = {1}]", Width, Height);
}
}
public struct Square {
public int Length;
public void Draw() { Console.WriteLine("Отображение квадрата."); }
public override string ToString() { return string.Format("[Сторона = {0}]", Length); }
// Rectangle (прямоугольник) можно явно преобразовать
// в Square (квадрат).
