3-Mavzu: Operatorlarni qayta yuklash. Reja Operatorni qayta yuklanish usuli

3-Mavzu: Operatorlarni qayta yuklash.
Reja
1. Operatorni qayta yuklanishi
2. Qayta yuklanish usuli

Tayanch so`z va iboralar

1. Operatorning qayta yuklanishi
Usullar bilan bir qatorda biz operatorlarni ham qayta yuklay olamiz. Masalan, bizda quyidagi Counter sinfi bor deylik:
class Counter
{
public int Value { get; set; }
}
Bu sinf hisoblagichni ifodalaydi, uning qiymati Value xossasida saqlanadi. Aytaylik, bizda Counter sinfining ikkita ob'ekti bor - biz ularni Value xususiyatiga asoslangan holda standart taqqoslash va qo'shish operatsiyalari yordamida solishtirmoqchi yoki qo'shmoqchi bo'lgan ikkita hisoblagich:
Counter c1 = new Counter { Value = 23 };
Counter c2 = new Counter { Value = 45 };
bool result = c1 > c2;
Counter c3 = c1 + c2;

Ammo hozirda Counter moslamalari uchun na solishtirish, na qo'shimcha mavjud. Bu operatsiyalar bir qancha ibtidoiy turlar uchun ishlatilishi mumkin. Masalan, sukut bo'yicha biz raqamli qiymatlarni qo'shishimiz mumkin, lekin kompilyator murakkab turdagi ob'ektlar - sinflar va tuzilmalarni qanday qo'shishni bilmaydi. Va buning uchun biz kerakli operatorlarni qayta yuklashimiz kerak. Operatorning qayta yuklanishi, biz operatorni aniqlamoqchi bo'lgan ob'ektlar uchun sinfda maxsus usulni aniqlashdan iborat:

public static qaytaruvchi_tip operator amal(parametrlar)
{ }
Bu usulda public static modifikatorlari bo'lishi kerak, chunki qayta yuklangan operator bu sinfning barcha ob'ektlari uchun ishlatiladi. Keyingi - qaytish turining nomi. Qaytish turi biz ob'ektlarni olishni xohlagan turni anglatadi. Masalan, ikkita Counter ob'ektini qo'shish natijasida biz yangi Counter ob'ektini olishni kutamiz. Va ikkalasini taqqoslash natijasida biz shartli ifoda to'g'ri yoki noto'g'ri ekanligini ko'rsatuvchi bool tipidagi ob'ektni olishni xohlaymiz. Ammo vazifaga qarab, qaytarish turlari har qanday bo'lishi mumkin.
Keyin usul nomi o'rniga operator kalit so'zi va operatorning o'zi bo'ladi. Va keyin parametrlar qavs ichida ko'rsatiladi. Ikkilik operatorlar ikkita parametrni, bitta operatorlar bitta parametrni oladi. Va har qanday holatda ham, parametrlardan biri turni - operator aniqlanadigan sinfni yoki tuzilishni ko'rsatishi kerak.
Masalan, Counter sinfi uchun bir qancha operatorlarni qayta yuklaylik:
class Counter
{
public int Value { get; set; }
public static Counter operator +(Counter c1, Counter c2)
{
return new Counter { Value = c1.Value + c2.Value };
}
public static bool operator >(Counter c1, Counter c2)
{
return c1.Value > c2.Value;
}
public static bool operator <(Counter c1, Counter c2)
{
return c1.Value < c2.Value;
}
}

Hamma qayta yuklangan operatorlar ikkilik bo'lgani uchun - ya'ni ular ikkita ob'ekt ustida bajariladi, keyin har bir qayta yuk uchun ikkita parametr bo'ladi.

Qo'shish amaliyotida biz Counter sinfining ikkita ob'ektini qo'shmoqchimiz, operator bu sinfning ikkita ob'ektini oladi. Va biz qo'shilish natijasida yangi Counter ob'ektini olishni xohlaganimiz uchun, bu sinf qaytish turi sifatida ham ishlatiladi. Ushbu operatorning barcha harakatlari Value xususiyati ikkala parametrning Value xususiyatining qiymatlarini birlashtirgan yangi ob'ektni yaratishga kamayadi:
public static Counter operator +(Counter c1, Counter c2)
{
return new Counter { Value = c1.Value + c2.Value };
}
Ikki taqqoslash operatori ham qayta aniqlandi. Agar biz bu taqqoslash operatsiyalaridan birini bekor qilsak, unda biz bu operatsiyalarning ikkinchisini ham bekor qilishimiz kerak. Taqqoslash operatorlarining o'zi Value xususiyatlarining qiymatlarini solishtiradi va taqqoslash natijasiga qarab true yoki false ni qaytaradi.
Endi biz dasturda qayta yuklangan operatorlardan foydalanamiz:
static void Main(string[] args)
{
Counter c1 = new Counter { Value = 23 };
Counter c2 = new Counter { Value = 45 };
bool result = c1 > c2;
Console.WriteLine(result); // false
Counter c3 = c1 + c2;
Console.WriteLine(c3.Value); // 23 + 45 = 68
Console.ReadKey();
}

Ta'kidlash joizki, aslida operator ta'rifi usul bo'lgani uchun, biz ham bu usulni qayta yuklashimiz, ya'ni uning uchun boshqa versiyani yaratishimiz mumkin. Masalan, Counter sinfiga boshqa operatorni qo'shamiz:

public static int operator +(Counter c1, int val)
{
return c1.Value + val;
}

Bu usul Value xususiyatining qiymatini va ba'zi sonlarni qo'shib, ularning summasini qaytaradi. Va biz ushbu operatordan ham foydalanishimiz mumkin:

Counter c1 = new Counter { Value = 23 };
int d = c1 + 27; // 50
Console.WriteLine(d);

Shuni yodda tutish kerakki, qayta yuklanish paytida parametrlar orqali operatorga uzatiladigan ob'ektlar o'zgartirilmasligi kerak. Masalan, biz Counter sinfi uchun qo'shimcha operatorini aniqlashimiz mumkin:

public static Counter operator ++(Counter c1)
{
c1.Value += 10;
return c1;
}

Operator yagona bo'lgani uchun, u faqat bitta parametrni oladi - bu operator aniqlangan sinf obyekti. Ammo bu o'sishning noto'g'ri ta'rifi, chunki operator o'z parametrlarining qiymatlarini o'zgartirmasligi kerak. Va qo'shimcha operatorning to'g'ri yuklanishi quyidagicha bo'ladi:

public static Counter operator ++(Counter c1)
{
return new Counter { Value = c1.Value + 10 };
}
Ya'ni, Value xossasida qo'shimcha qiymatni o'z ichiga olgan yangi ob'ekt qaytariladi.
Shu bilan birga, biz prefiks va postfiks (shuningdek, kamayish) uchun alohida operatorlarni belgilashimiz shart emas, chunki har ikkala holatda ham bitta dastur ishlaydi.
Masalan, prefiksni oshirish operatsiyasidan foydalanaylik:
Counter counter = new Counter() { Value = 10 };
Console.WriteLine($"{counter.Value}"); // 10
Console.WriteLine($"{(++counter).Value}"); // 20
Console.WriteLine($"{counter.Value}"); // 20

Konsol chiqishi:

10
20
20

Endi biz postfiks o'sishidan foydalanamiz:

Counter counter = new Counter() { Value = 10 };
Console.WriteLine($"{counter.Value}"); // 10
Console.WriteLine($"{(counter++).Value}"); // 10
Console.WriteLine($"{counter.Value}"); // 20

Konsol chiqishi:

10
20
20

Shuni ham ta'kidlash joizki, biz true va false operatorlarini bekor qilishimiz mumkin. Masalan, ularni Counter sinfida aniqlaylik:

class Counter
{
public int Value { get; set; }
public static bool operator true(Counter c1)
{
return c1.Value != 0;
}
public static bool operator false(Counter c1)
{
return c1.Value == 0;
}
// sinfning qolgan qismi
}

Bu turdagi ob'ektni shart sifatida ishlatmoqchi bo'lganimizda, bu operatorlar qayta yuklangan. Masalan:

Counter counter = new Counter() { Value = 0 };
if (counter)
Console.WriteLine(true);
else
Console.WriteLine(false);

Operatorlarni qayta yuklashda shuni yodda tutingki, hamma operatorlar ham qayta yuklanishi mumkin emas. Xususan, biz quyidagi operatorlarni qayta yuklay olamiz:

• 
  unar operatorlar +, -,!, ~, ++, -
  
• 
  binar operatorlar +, -, *, /,%
  
• 
  solishtirish operatsiyalari == ,! =, <,>, <=,> =
  
• 
  mantiqiy operatorlar &&, ||
  

Va qayta yuklab bo'lmaydigan bir qancha operatorlar bor, masalan, tenglik operatori = yoki ternar operatori?:, va boshqalar.

Qayta yuklangan operatorlarning to'liq ro'yxatini msdn hujjatlarida topish mumkin.
Operatorlarni qayta yuklashda shuni ham unutmaslik kerakki, biz operatorning ustunligini yoki uning assotsiativligini o'zgartira olmaymiz, biz yangi operator yaratolmaymiz yoki operatorlar mantig'ini turlarga ko'ra o'zgartira olmaymiz, bu .NETda boshlang`ich holat bo`yicha hisoblanadi.