Nomlar fazosidan foydalanish dll kutubxona yaratish va bogʻlash. Nazariy ma’lumot
Unar va binar operatorlarni qayta yuklash
Yüklə 0,6 Mb. Pdf görüntüsü
|
|
Unar va binar operatorlarni qayta yuklash.
Nazariy ma’lumotlar. C# da unar va ikkilik operatorlar haddan tashqari yuklanishi mumkin, ya'ni ularning xatti-harakatlari maxsus turlar uchun aniqlanishi mumkin. Operator kalit so'zi ortiqcha yuklangan operatorlarni aniqlash uchun ishlatiladi. Unar operatorlar bitta operandda, ikkilik operatorlar esa ikkita operandda ishlovchi operatorlardir. C# tilida unar operatorlarga mantiqiy NO (!) va manfiy (-) operatorlar kiradi, ikkilik operatorlarga esa qo‘shish (+), ayirish (-) va taqqoslash (==) operatorlari kiradi. C# da birlik va ikkilik operatorlarni haddan tashqari yuklaganda, amal qilish kerak bo'lgan ma'lum ko'rsatmalar mavjud: Birlik operatorlar aniqlanayotgan tur bilan bir xil turdagi bitta operandni olishlari va bir xil turdagi natijani qaytarishlari kerak. Ikkilik operatorlar ikkita operandni olishlari kerak, kamida bitta operand aniqlangan turdagi bo'lishi kerak. Operator bir xil turdagi natijani qaytarishi kerak. Haddan tashqari yuklangan operatorlar statik usullar bo'lishi kerak. Quyidagi misolda maxsus ComplexNumber sinfi uchun unar inkor operatorining (- ) ortiqcha yuklanishi ko‘rsatilgan: public class ComplexNumber { public double Real { get ; set ; } public double Imaginary { get ; set ; } public static ComplexNumber operator -(ComplexNumber c) { return new ComplexNumber { Real = -c.Real, Imaginary = -c.Imaginary }; } } Bu kod ComplexNumber klassi misollari uchun unar inkor operatorining (-) harakatini belgilaydi. Operator ComplexNumber tipidagi bitta operandni oladi va uning haqiqiy va xayoliy qismlari inkor etilgan holda yangi ComplexNumber misolini qaytaradi. Quyidagi misolda maxsus Money sinfi uchun ikkilik qo‘shish operatorining (+) ortiqcha yuklanishi ko‘rsatilgan: public class Money { public decimal Amount { get ; set ; } public static Money operator +(Money m1, Money m2) { return new Money { Amount = m1.Amount + m2.Amount }; } } Ushbu kod Money sinfi misollari uchun ikkilik qo'shish operatorining (+) harakatini belgilaydi. Operator Money tipidagi ikkita operandni oladi va uning Amount xususiyati operandlarning Summa xossalari yigʻindisiga o‘rnatilgan yangi Money misolini qaytaradi. Xulosa qilib aytganda, C# da unar va ikkilik operatorlarni haddan tashqari yuklash maxsus turlarga ushbu operatorlar uchun o'z xatti-harakatlarini aniqlash imkonini beradi, bu ularni kodda foydalanish uchun yanada moslashuvchan va intuitiv qiladi. Usullar bilan bir qatorda biz operatorlarni ortiqcha yuklashimiz ham mumkin. Masalan, bizda quyidagi Counter klassi bor deylik: class Counter { public int Value { get ; set ; } } Ushbu sinf ba'zi bir hisoblagichlarni ifodalaydi, ularning qiymati Value xususiyatida saqlanadi. Aytaylik, bizda hisoblagich sinfining ikkita ob’ekti bor - biz ularni solishtirish yoki qo'shish istagan ikkita hisoblagichni Value xususiyati asosida standart taqqoslash va qo'shish operatsiyalari yordamida: Counter c1 = new Counter { Value = 23 }; Counter c2 = new Counter { Value = 45 }; bool result = c1 > c2; Counter c3 = c1 + c2; Ammo hozirgi vaqtda Counter moslamalari uchun na taqqoslash operatsiyasi, na qo'shish operatsiyasi mavjud emas. Ushbu operatsiyalar bir qator ibtidoiy turlari uchun ishlatilishi mumkin. Masalan, sukut bo'yicha biz raqamli qiymatlarni qo'shishimiz mumkin, ammo kompilyator murakkab turdagi ob’ektlar - sinflar va tuzilmalarni qanday qo'shishni bilmaydi. Va buning uchun biz kerakli operatorlarni ortiqcha yuklashimiz kerak. Operatorning ortiqcha yuklanishi biz operatorni aniqlamoqchi bo'lgan ob’ektlar uchun sinfda maxsus usulni belgilashdan iborat: public static qaytarish_tip operator оператор(parametrlar) { } Ushbu usul umumiy statik modifikatorlarga ega bo'lishi kerak, chunki haddan tashqari yuklangan operator ushbu sinfning barcha ob’ektlari uchun ishlatiladi. Keyingi qaytish turining nomi. Qaytish turi biz ob’ektlarni olishni istagan turni ifodalaydi. Masalan, ikkita Counter moslamasini qo'shish natijasida biz yangi Counter moslamasini olishni kutmoqdamiz. Va ikkalasini taqqoslash natijasida biz bool tipidagi ob’ektni olishni istaymiz, bu shartli ifoda to'gʻri yoki yolgʻon ekanligini ko'rsatadi. Ammo vazifaga qarab, qaytarish turlari har qanday bo'lishi mumkin. Keyin usul nomi o'rniga operator kalit so'zi va operatorning o'zi mavjud. Va keyin parametrlar qavs ichida keltirilgan. Ikkilik operatorlar ikkita parametrni, unaryali operatorlar bitta parametrni oladi. Va har qanday holatda, parametrlardan biri operatorni aniqlaydigan sinf yoki tuzilmani - turini ko'rsatishi kerak. Masalan, Counter klassi uchun bir qator operatorlarni ortiqcha 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; } } Barcha ortiqcha yuklangan operatorlar ikkilik bo'lganligi sababli, ya'ni ular ikkita ob’ekt ustida bajariladi, keyin har bir ortiqcha yuk uchun ikkita parametr bo'ladi. Qo'shish amalida biz Counter sinfining ikkita moslamasini qo'shmoqchimiz, operator shu sinfning ikkita ob’ektini oladi. Qo'shish natijasida biz yangi Counter ob’ektini olishni istaganimiz uchun, bu sinf qaytish turi sifatida ham ishlatiladi. Ushbu operatorning barcha harakatlari Value xususiyati ikkala parametrning Value xususiyatining qiymatlarini birlashtirgan yangi ob’ektni yaratishga qisqartiriladi: public static Counter operator +(Counter c1, Counter c2) { return new Counter { Value = c1.Value + c2.Value }; } Ikkala taqqoslash operatorlari ham qayta aniqlandi. Agar biz ushbu taqqoslash operatsiyalaridan birini bekor qilsak, unda biz ushbu operatsiyalarning ikkinchisini ham bekor qilishimiz kerak. Taqqoslash operatorlari o'zlari Value xususiyatlarining qiymatlarini taqqoslaydilar va taqqoslash natijalariga qarab "true" yoki "false" qiymatlarini qaytaradilar. Endi biz dasturda ortiqcha yuklangan operatorlardan foydalanamiz: using System; namespace Qayta { 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; } } class Program { 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(); } } } Shunisi e'tiborga loyiqki, aslida operatorning ta'rifi bu usul ekan, biz ushbu usulni ortiqcha yuklay olamiz, ya'ni buning uchun boshqa versiyasini yaratamiz. Masalan, Counter sinfiga boshqa operator qo'shaylik: public static int operator +(Counter c1, int val) { return c1.Value + val; } Ushbu usul Value xususiyati va sonini qo'shib, ularning yigʻindisini 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, ortiqcha yuk paytida operatorga parametrlar orqali uzatiladigan ob’ektlar o'zgartirilmasligi kerak. Masalan, biz Counter klassi uchun o'sish operatorini aniqlay olamiz: public static Counter operator ++(Counter c1) { c1.Value += 10; return c1; } Operator unary bo'lgani uchun u faqat bitta parametrni oladi - bu operator aniqlangan sinf ob’ekti. Ammo bu o'sishning noto'gʻri ta'rifi, chunki operator o'z parametrlari qiymatlarini o'zgartirmasligi kerak. Va o'sish operatorining yanada to'gʻri yuklanishi quyidagicha ko'rinadi: public static Counter operator ++(Counter c1) { return new Counter { Value = c1.Value + 10 }; } Ya'ni, Value xususiyatidagi oshirilgan qiymatni o'z ichiga olgan yangi ob’ekt qaytariladi. Shu bilan birga, biz prefiks va postfiks qo'shimchalari (shuningdek, pasayishlar) uchun alohida operatorlarni belgilashimiz shart emas, chunki bitta dastur ikkala holatda ham ishlaydi. Masalan, prefiksni oshirish amalidan foydalanamiz: Counter counter = new Counter() { Value = 10 }; Console.WriteLine($"{counter.Value}"); // 10 Console.WriteLine($"{(++counter).Value}"); // 20 Console.WriteLine($"{counter.Value}"); // 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 Shuni ham ta'kidlash joizki, biz haqiqiy va noto'gʻri operatorlarni bekor qilishimiz mumkin. Masalan, ularni Counter sinfida aniqlaymiz: 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; } // остальное содержимое класса } Ushbu turdagi operatorlardan biz shartli ravishda foydalanmoqchi bo'lganimizda, ushbu operatorlar haddan tashqari yuklanadi. Masalan: Counter counter = new Counter() { Value = 0 }; if (counter) Console.WriteLine( true ); else Console.WriteLine( false ); Operatorlarni haddan tashqari yuklaganda, barcha operatorlar haddan tashqari yuklanmasligi mumkinligini yodda tuting. Xususan, biz quyidagi operatorlarni ortiqcha yuklay olamiz: unary operatorlari +, -,!, ~, ++, - ikkilik operatorlar +, -, *, /,% taqqoslash operatsiyalari == ,! =, <,>, <=,> = |