| Twit | Дата: Воскресенье, 17.03.2013, 12:41 | Сообщение # 1 |
 Приятно Царь
| Перегрузка операторов позволяет определить воздействие операторов на объекты, т.е., благодаря перегрузке операторов, мы можем применять их к объектам. В принципе, перегрузка оператора осуществляется специальным методом. Метод перегруженного операторов должен объявляться как public static. Операторы бывают унарные и бинарные. Унарные операторы работают с одним операндом, а бинарные - с двумя. Для указания перегрузки операторов используется ключевое слово operator. В зависимости от количества операндов, различают две общие формы операторных методов. Вот и они:
public static возвращаемый_тип operator #(тип_операнда операнд)
{
//тело метода унарного оператора
}
public static возвращаемый_тип operator #(тип_операнда1 операнд1, тип_операнда2 операнд2)
{
//тело метода бинарного оператора
}
Теперь некоторые ограничения на перегрузку операторов:
- приоритет операторов не меняется (в C# приоритет операторов можно считать таким же, как и в C/C++);
- нельзя менять определенное в языке для конкретного оператора количество операндов;
- тело метода перегружаемого оператора должно определять действия оператора, по отношению к объекту/объектам текущего класса.
- операторы сравнения (кроме равенства) надо определять по два, т.е., если есть '>', то должно быть и '<';
- нельзя перегружать операторы сравнения
И, наконец, перегрузим несколько операторов для нашего класса Matrix. В нем я буду использовать условный оператор if(выражение){блок1;}else{блок2;}. Для тех, кто с ним не знаком, объясняю... Если выражение в круглых скобках принимает значение истины, то выполняется блок1, иначе - блок2, следующий за else. Все просто!
//Этуот пример можно было бы сделать красивее,
//с динамическим распределением, но некоторым
//это пока будет сложно
using Sc=System.Console;
class Matrix// класс матрицы
{
//-Объявим-закрытый-член-класса----------
//-Массив-10x10-целочисленных-переменных-
//-Элементов-матрицы---------------------
int[,] element=new int[4,4];
//----Конструктор-по-умолчанию---------
public Matrix()
{
int i,j;
//цикл для прохода по строкам
for(i=0;i<4;i++)
{ //цикл для прохода по элементам строки
for(j=0;j<4;j++)
{ //установка в 0 каждого элемента
element[i,j]=0;
}
}
}
//-теперь-определим-методы-присваивания-и---
//-получения-значения-определенному-элементу-
public void SetValue(int line,int row,int value)
{
element[line,row]=value;
}
public int GetValue(int line,int row)
{
return element[line,row];
}
//-определим-перегруженный-метод-вывода-
public void Print()//вывод всей матрицы
{
int i,j;//переменные для циклов
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(i,j));
}
Sc.WriteLine();
}Sc.ReadLine();
}
public void Print(int line)//вывод строки
{
int j;
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(line,j));
}
Sc.WriteLine();
Sc.ReadLine();
}
public void Print(int line,int row)//вывод элемента
{
Sc.WriteLine("Element["+line+","+row+"]="+GetValue(line,row));
}
//-и-наконец-метод-ввода-всех-элементов-
public void Scan()
{
int i,j,ii;
for(i=0;i<4;i++)
{
string str1;
ii=i+1;
Sc.WriteLine("Enter string #"+ii);
for(j=0;j<4;j++)
{
Sc.Write("Enter value for element["+i+","+j+"](then press Enter)=>");
str1=Sc.ReadLine();
element[i,j]=int.Parse(str1);
}
Sc.WriteLine();
}
}
public int Sum()//счет суммы всех элементов
{
int sum=0;
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) sum=sum+element[i,j];
//или sum+=element[i,j];
}
return sum;
}
//А вот и они - операторы
public static Matrix operator ++(Matrix m)
{//унарный оператор инкремента
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) m.element[i,j]++;
}
return m;
}
public static Matrix operator +(Matrix m1,Matrix m2)
{//бинарный оператор сложения
Matrix mresult=new Matrix();
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) mresult.element[i,j]=m1.element[i,j]+m2.element[i,j];
}
return mresult;
}
//операторы сравнения возвращают значения
//типа bool (1 или 0)
//часто используются в выражениях
//условных операторов
public static bool operator >(Matrix m1,Matrix m2)
{
if(m1.Sum()>m2.Sum()) return true;
else return false;
}
public static bool operator <(Matrix m1,Matrix m2)
{
if(m1.Sum()<m2.Sum()) return true;
else return false;
}
}
class Application
{
public static void Main()
{
Matrix matrix1=new Matrix();
Matrix matrix2=new Matrix();
Matrix matrix3=new Matrix();
Sc.WriteLine("Input 1st matrix:");
matrix1.Scan();matrix1++;
Sc.WriteLine("1st matrix incremented:");
matrix1.Print();
Sc.WriteLine("input 2nd matrix:");
matrix2.Scan();
matrix3=matrix1+matrix2;
Sc.WriteLine("matrix1 + matrix2 is");
matrix3.Print();
if(matrix3>matrix2) Sc.WriteLine("matrix3 is bigger");
else Sc.WriteLine("matrix3 is not bigger");
Sc.ReadLine();
}
}
Чтобы перегрузить операторы '==' и '!=' необходимо переопределить методы Equals() и GetHashCode() базового класса Object (или типа object). Для полного счастья, сделаем уже и это. Но, для начала, я расскажу немного о упаковке/распаковке. Все классы автоматически наследуют фундаментальный класс Object. Следовательно, любой тип или класс можно привести к типу object. Возможна и обратная процедура. Приведение объекта к объекту базового типа object и называется упаковкой. Распаковка - это обратная процедура. В следующем примере мы воспользуемся распаковкой в переопределении метода Equals(object o). Критерий равенства матриц - равенство сумм всех элементов обеих матриц. Просто добавляем следующие методы в наш класс Matrix...
public override int GetHashCode()
{
return 100;
}
public override bool Equals(object o)
{
//unpack it now
Matrix matr=(Matrix)o;
if(Sum()==matr.Sum()) return true;
else return false;
}
public static bool operator ==(Matrix m1,Matrix m2)
{
if(m1.Sum()==m2.Sum()) return true;
else return false;
}
public static bool operator !=(Matrix m1,Matrix m2)
{
if(m1.Sum()!=m2.Sum()) return true;
else return false;
}
И следующие строки в конец метода Main()...
if(matrix1==matrix2) Sc.WriteLine("matrix1=matrix2");
else Sc.WriteLine("matrix1!=matrix2");
Sc.ReadLine();
Далее комментировать эту прогу я не вижу смысла. Командная строка, csc имя_файла & GO! Ну, создавать классы умеем, интерфейсы - умеем, умеем наследовать, умеем перегружать операторы и методы, умеем пользоваться объектами, создавать новые типы данных, если вы, конечно, прочитали все мои статьи. Можно, сказать, что теперь и ты знаешь основы объектно-ориентированного программирования, Нео!
Кризис.Разные мнения.Идеи.
Первое правило шахмат - хочешь быть умнее? Играй с более умным соперником.
|
|
| |
