«C# dasturlash tili» O’quv qo’llanma
«C# dasturlash tili»
O’quv qo’llanma
Umumiy o’quv soati –110 s.
Shu jumladan:
Ma’ruza –32 s.
Amaliy mashg’ulotlar –21 s.
Laboratoriya mashg’ulotlari –27 s.
Mustaqil ta’lim soati –30 s.
Annotatsiya
Qo’llanmada .NET muhitida yaratilgan yangi C# programmalash tilining asosiy aspektlari,
jumladan: berilganlar tipi, operatorlar, boshqaruvchi ko’rsatmalar, sinflar, interfeyslar va C#
sinflari kutubxonasining imkoniyatlari oddiy misollar yordamida bayon qilingan. Undan C#da
programma tuzuvchilar va xususan axborot texnologiyalari bilan bog’liq bo’lgan
mutaxassisliklar talabalari va mustaqil o’rganuvchilar foydalanishlari mumkin.
BBK 32.973.26-018.2.75
Tuzuvchilar: f.-m.n.d., prof. Aripov M.M.
katta. o’qit. T.Xojiev
assistent I.O.Xajiev
Taqrizchi: f-m.n.n., dotsent Xakimov M.X.
Kerak. 170209. yego glavno’m arxitekto-rom bo’l veduhiy spesialist v etoy oblasti — Anders
Xeylsberg (Anders Hejlsberg).C#-— pryamoy potomok dvux samo’x uspeshno’x v mire
kompyuterno’x yazo’kov: S i CQQ.
Ot S on unasledoval sintaksis, klyuchevo’ye slova i operatoro’. On pozvolyaet postroit i usovershenstvovat ob’ektnuyu model, opredelennuyu v CQQ. Krome togo, S#
blizko svyazan s drugim ochen uspeshno’m yazo’kom: Java. Imeya obhee proisxojdenie,
no razlichayas vo mnogix vajno’x aspektax, C#i Java — eto skoree "dvoyurodno’ye bratya". Naprimer, oni oba podderjivayut programmirovanie raspredelenno’x sistem i
oba ispolzuyut promejutochno’y kod dlya dostijeniya perenosimosti, no razlichayutsya
pri etom v detalyax realizatsii.
I yehe. Podobno Java yazo’k C# predlagaet sredstva dinamicheskogo obnarujeniya oshibok, obespecheniya bezopasnosti i upravlyaemogo vo’polneniya programm. No, v otlichie
ot Java, C# daet programmistam dostup k ukazatelyam. Takim obrazom, C#sochetaet
pervozdannuyu moh CQQ s tipovoy bezopasnostyu Java, kotoraya obespechivaetsya nalichiem mexanizma kontrolya tipov (type checking) i korrektno’m ispolzovaniem
shablonno’x klassov (template class). Bolee togo, yazo’k C#otlichaetsya tem, chto kompromiss mejdu mohyu i nadejnostyu thatelno sbalansirovan i prakticheski prozrachen (ne zameten dlya polzovatelya ili programmo’).
Kitobning strukturasi. Tilning nihoyatda kattaligini hisobga olib, uni ma’lum bir qismlarga
bo’lgan holda bayon etish maqsadga muvofiqdir. Jumladan, C# tili to’g’risidagi asosiy
tushunchalar, kalit so’zlarning vazifalari, sintaksis va programmalash muhiti, unda dastlabki
programmalar yozishni o’rganish kabilar mazkur kitobning tarkibini tashkil etadi. Qolgan
qismlari to’g’risidagi ma’lumotlarni bayon etish esa mualliflarning keyingi rejalari bo’lib
hisoblanadi.
Programma ta’minoti to’g’risida shuni aytib o’tish kerakki, keltirilgan programmalarni
kompilyatsiya qilish va bajarish uchun kompyuterda Visual Studio .Net 7 paketi va .NET
Framework qobig’i o’rnatilgan bo’lishi kerak.
Mundarija
Kirish .............................................................................................................
1-bob. Genealogik daraxt. S tili, yoki programmalashning yangi davrini boshlanishi
OYP va SQQ yaralishi to’g’risida.............................................................................
Internet va Java tilining paydo bo’lishi...............................................................
C# ning paydo bo’lishi va uning .NET Framework qobig’i bilan bog’liqligi.......
.NET Framework muhiti to’g’risida. CLR sistemasi. Boshqariladigan kodni boshqarilmaydigan
kod bilan taqqoslash ...................................................................
Universal tilning Spesifikatsiyasi .......................................................................
2-bob. Ob’ektga yo’naltirilgan programmalashtirish
Inkapsulyatsiya. Polimorfizm. Merosxo’rlik......................................
Oddiy programmalar tuzish. csc.exe buyruq satri kompilyatoridan foydalanish.....
Programma tekstini kiritish, kompilyatsiya qilish va bajarishga berish.
Visual Studio IDE dan foydalanish
Sintaktik xatoliklarni qayta ishlash
Oddiy programma tuzishlarga misollar.................................
Berilganlarning boshqa tiplari. .......
Boshqarish ko’rsatmalari: if va for .....................................
Kod bloklaridan foydalanish.........................
Nuqta vergul va chekinishlardan foydalanish. .....................
C# ning kalit so’zlari................
Identifikatorlar.................
C# sinflari kutubxonasi ...........
3-bob. Berilganlarning tiplari, literallar va o’zgaruvchilar....
C# da qiymatlar tipi. Butun qiymatli va suzuvchi nuqtali sonlarni tasvirlash uchun tiplar.
decimal tipi. Simvollar. bool tipi. ......................
Berilganlarni bosib chiqarish to’g’risida........
Literallar. O’noltilik literallar. Satrli literallar............
O’zgaruvchilarning oddiy va dinamik initsializatsiyasi ...........
O’zgaruvchilarning ko’rinish va mavjudlik vaqti........
Tiplarni oddiy va avtomatik almashtirish variantlari.........
4-bob. Operatorlar. Arifmetik operatorlar...................
Inkrement i dekrement.........
Munosabat operatorlari va mantiqiy operatorlar. ............
Oddiy va qo’shma o’zlashtirish operatorlari.
Razryadli VA,YOKI va EMAS....................
Siljitish operatori ....................
Razryadli qo’shma o’zlashtirish operatorlari. ? operatori .....
Probel va kichik qavslardan foydalanish. Operatorlar imtiyozi....
5-bob. Boshqarish uchun ko’rsatma. If, ichma-ich joylashgan if va if-else-if
ko’rsatmalari...............
Switch va ichma-ich joylashgan switch .................................
for ko’rinishidagi bir yoki bir necha o’zgaruvchili sikl operatorlari ...................
Shartli ifodalar ......................
Cheksiz va tanasiz sikllar ........................
while va do-while sikli .................
foreach sikli .......................
Sikldan chiqish uchun break dan foydalanish
Continue, return va goto...............
6-bob. Sinflar, ob’ektlar va usullarning umumiy ko’rinishlari va ta’riflari........
Ob’ektlarni hosil qilish................
Sso’lochnaya tipidagi o’zgaruvchilar va ularga qiymatlar berish ..................
Usullar va ularni Building sinfiga qo’shish ................
Usuldan qaytish. Qiymatni qaytarish. Parametrlardan foydalanish.
Konstruktorlar va parametrlashgan konstruktorlarni Building sinfiga qo’shish.........
new operatoridan foydalanish.
"musor"larni yig’ish. Destruktorlar va ulardan foydalanish............
this kalit so’zi.................
7-bob. Massivlar va satrlar. Bir o’lchovli massivlar. Massivlarni initsializa
siyalash......
"Chegaraviy rejim"ni saqlash ......
Ikki o’lchovli va ko’p o’lchovli massivlar........
Ko’p o’lchovli massivlarni initsializatsiyalash. Buzilgan massivlar.
Length xossasidan foydalanish ................
foreach sikli
Satrlar va ularni tuzish. SAtrlar bilan ishlash
Satrlar massivi va o’zgarmasligi..............
switch-instruksiyalarda satrlardan foydalanish. ............
8-bob. C# da ishlash bo’yicha qisqacha ko’rsatma ....................................
9-bob. Ilovalar ....................................................................................
Adabiyot .............................................................................
C# da programmalash elementlari ..........................................................
C# alfaviti ................................................................................................
Identifikatorlar, kalit so’zlar ..................................................
Berilganlar: o’zgarmaslar ..............................................................
O’zgaruvchilar ...................................................................................
Turlar ...............................................................................................
2-bob. Matematik funksiyalar .................................................................
Ifodalar. .......................................................................................
Arifmetik amallar ........................................................................
3-bob. Operatorlar. Qiymat berish operatori .....................................
Shartli va shartsiz o’tish operatorlari .....................................
Takrorlash operatori ...................................................................
4-bob. Massivlar: bir o’lchovli va ko’p o’lchovli massivlar ................
5-bob. Funksiyalar ..................................................................................
Kirish
Oxirgi yillarda C# tili va u bilan bog’liq bo’lgan muhit, ya’ni .NET platformasi dasturiy ta’minot
yaratuvchilar uchun asosiy yangi texnologiya bo’lib kelmoqda. .NET platformasi orqali
Windows muhitida hosil qilish mumkin bo’lgan ixtiyoriy dasturlarni yaratish mumkin. C# tili esa
yangi til hisoblanib, ushbu muhit uchun maxsus ishlab chiqilgan. C# tilidan foydalanib, dinamik
WEB – sahifalarni, tarqatma texnologiya asosida yaratilgan dasturlarni, berilganlar bazasi bilan
ishlovchi komponentlarni yoki oynali Windows dasturlarini yaratish mumkin. C#tili yordamida
tarmoq yoki Internet dasturlaridan tashqari, Windows platformasida ishlovchi ixtiyoriy dasturni
yaratish mumkin. C# tilida .NET platformasi orqali Windows muhitida dasturlar yaratish
metodikasini mukammallashtirish ko’zda tutilgan.
1. .NET arxitekturasi
.NET (.NET runtime) platformasida kod bajarilishi.
Boshqariluvchi kod (managed code).
Oraliq til.
Tiplarning umumiy tizimi (Common Type System, CTS).
Ichki qurilgan .NET klasslari.
Tilning umumiy spesifikatsiyasi (Common Language Specification, CLS). Kompilyatsiya JustIn-Time (JIT).
Keraksiz ma’lumotlarni yo’qotish (CLR).
2. C# tili va birinchi proekt.
C# tili qurilishi.
Asosiy qismlari.
Konsol va Windows dasturlar xosil qilinishi.
Ma’lumki, kompyuter tillari o’z-o’zidan birdaniga yangidan emas, balki o’zaro bir-biriga
bog’liqlikda vujudga keladi. Har qanday yaratilgan yangi til u yoki bu shaklda oldinroq
yaratilgan mavjud tillarning xossalarini o’ziga meros qilib oladi, ya’ni ketma-ketlik prinsipi
amalga oshiriladi. Natijada bitta tilning imkoniyatlari boshqalari tomonidan foydalaniladi va
ma’lum bir joylari mukammallashtiriladi. Kompyuter tillarining evolyutsiyasi shunday tarzda
ro’y beradi va dasturlash mahorati takomillashtiriladi.
C#tili ham yuqoridagilardan istisno emas. U boshqa dasturlash tillarining ko’plab foydali
imkoniyatlarini meros qilib oldi va dunyoda eng ko’p qo’llaniladigan ikkita kompyuter tillari –
Si va SQQ, shuningdek Java tili bilan uzviy bog’liqdir. C#ni tushunish uchun mazkur bog’liqlik
tabiatini aniqlab olish kerak, shuning uchun oldin biz ushbu uch tilning rivojlanish tarixi
to’g’risida to’xtalib o’tamiz.
C#tilining yaratilishi – dasturlashning zamonaviy davri boshlanishidir
C#tili 1972 yilda Nyu-Djersi shtatining Myurrey-xill shahrida Bell Laboratories
kompaniyasining tizimli dastur tuzuvchisi Dennis Richi tomonidan yaratilgan. Bu til o’zini
shunchalik yaxshi ko’rsatdiki, oxir oqibatda unga Unix operatsion tizimlarining 90% yadro
kodlari yozildi. (Ma’lumki, ular oldin past darajadagi til – assemblerda yozishgan). C#ning
vujudga kelishidan oldinroq yaratilgan tillardan, Pascal ulardan eng mashhuri hisoblanadi va u
yetarli darajada muvaffaqiyatli foydalanilgan.
1960 yillarda dasturlash texnologiyalaridagi strukturaviy dasturlashlarning paydo bo’lishiga olib
kelgan katta o’zgarishlar C#tilini yaratish uchun asosiy imkoniyatlarni belgilab berdi.
Strukturaviy dasturlashlarning paydo bo’lishiga qadar katta dasturlarni yozish qiyin bo’lgan. Satr
kodlari miqdorining oshishi sababli dasturlarning o’tish joylari chalkash masalalarga aylanib
ketishiga olib keladi. Strukturaviy tillar dastur tuzuvchisiga shartli operatorlarni, lokal
o’zgaradigan tartiblarni va boshqa mukammallashtirishlarni qo’shib bu muammoni hal qildi. Shu
tarzda nisbatan katta dasturlarni yozish imkoniyati vujudga keldi.
Aynan C#tili kuch, elegantlik va ma’nodorlikni o’zida muvaffaqiyatli birlashtirgan birinchi
strukturaviy til bo’ldi. Uning bo’lishi mumkin bo’lgan xatolar mas’uliyatini tilga emas dastur
tuzuvchi zimmasiga yuklaydigan prinsiplar bilan inobatga olgan holda sintaksisdan
foydalanishdagi qisqalik va osonlik kabi xususiyatlari tezda ko’plab tarafdorlarini topdi.
Bugungi kunda biz mazkur sifatlarni o’z o’zidan anglashiladigan deb hisoblaymiz, lekin C#da
birinchi marotaba dastur tuzuvchiga zarur bo’lgan ajoyib yangi imkoniyatlar
mujassamlashtirilgan. Natijada 1980 yillardan boshlab C#strukturaviy dasturlash tillari orasida
eng ko’p foydalaniladiganlaridan biri bo’lib qoldi.
Biroq, dasturlashning rivojlantirish choralariga ko’ra bundan ham kattaroq dasturlarni qayta
ishlash muammosi kelib chiqmoqda. Loyiha kodi ma’lum bir hajmga yetgan zahoti (uning
raqamli ahamiyati dastur, dastur tuzuvchi, foydalanilgan instrumentlarga bog’liq bo’ladi, lekin
taxminan 5000 satr kodlari nazarda tutilayapti) S#-dasturlarini tushunish va kuzatib borishda
qiyinchiliklar yuzaga keladi.
OYD ning vujudga kelishi va SQQ tilining yaratilishi
1970 yillar oxirida ko’plab loyihalar S strukturaviy dasturlash tili yordamida qayta ishlash uchun
oson bo’lgan eng yuqori ko’rsatkichga erishgan. Endi bularga yangicha munosabat talab qilina
boshlandi va ushbu muammoni hal etish uchun dastur tuzuvchiga katta hajmdagi dasturlar bilan
ishlash imkonini beruvchi ob’ektga yo’naltirilgan dasturlash (OYD) yaratildi. Garchi, o’sha
vaqtda S eng ommabop til bo’lishiga qaramasdan OYD ni qo’llab-quvvatlamadi. Shu bois uning
ob’ektga yo’naltirilgan (keyinchalik SQQ deb atalgan) versiyasini yaratish zaruriyati tug’ildi.
Bu versiya o’sha Bell Laboratories kompaniyasining xodimi Byarn Straustrap tomonidan 1979
yil boshida ishlab chiqilgan. Dastlab yangi til “S sinflar bilan” degan nom oldi. Lekin, u 1983
yilda SQQ deb qayta nomlangan. Bo’lib, o’zida S tilini to’la qamrab oladi (ya’ni, S SQQ uchun
poydevor bo’lib xizmat qiladi) va ob’ektga yo’naltirilgan dasturlashni qo’llab-quvvatlash uchun
mo’ljallangan yangi imkoniyatlarni namoyon qiladi. Aslida SQQ S tilining ob’ektga
yo’naltirilgan versiyasi hisoblanadi. Shuning uchun C#ni biluvchi dastur tuzuvchi uchun SQQ da
dasturlashga o’tishda yangi tilni emas, balki faqatgina OYD ning yangi konsepsiyasini o’rganish
kifoya qiladi.
SQQ tili uzoq vaqt mobaynida sifatga etibor bermay, faqat miqdor oshirish, hajmni kengaytirish
jihatidan rivojlandi. 1990 yillar boshida u ommaviy ravishda qo’llanila boshlandi va katta
yutuqlarga erishdi. O’n yillikning oxirida esa dasturiy ta’minotni qayta ishlashda eng keng
foydalaniladigan va bugungi kunda ham peshqadamlik qilayotgan tilga aylandi.
Shuni anglash muhimki, SQQ ni ishlab chiqilishi yangi dasturlash tilini yaratishga intilish
hisoblanmaydi, balki mavjud tilni faqatgina yetarli darajada muvaffaqiyatli takomillashtiryapti
va to’ldiryapti. Bunday qarash, hozirda ham kompyuter tillarini rivojlantirishning yangi
yo’nalishlarida ham qo’llanilayapti.
Internet va Java tilining vujudga kelishi
Dasturlash tillarini rivojlantirishdagi keyingi katta muvaffaqiyatlardan biri Java tili bo’ldi.
Dastlab Oak deb atalgan Java ustida ishlash 1991 yilda Sun Microsystems kompaniyasida
boshlandi. Djeyms Gosling, Patrik Noton, Kris Vort, Ed Frank va Mayk Sheridan mazkur tilning
asosiy ishlab chiquvchilari bo’lgan.
Java SQQ tilidan olingan sintaksis va strategiya bilan strukturaviy ob’ektga yo’naltirilgan til
hisoblanadi. Java innovatsiyalari axborot texnologiyalarining shiddat bilan rivojlanishi va
Internet foydalanuvchilari sonining tez sur’atlarda o’sishi, shuningdek dasturlash
texnologiyalarining takomillashtirilishini ta’minladi. Internet ning keng tarqalishigacha yozilgan
ko’plab dasturlar aniq protsessorlar va muayyan operatsion tizimlar uchun kompilyatsiya qilindi.
Garchi dastur tuzuvchilar muvaffaqiyatli dasturlarni yozishda deyarli har doim koddan takroriy
foydalanish savolini bergan bo’lsalar-da, bu savol birinchi navbatdagisi emas edi. Biroq, Internet
ning (ya’ni kompyuter tarmog’i orqali turli xildagi protsessorlar va operatsion tizimlarni
birlashtirish imkoniyatlarining paydo bo’lishi) rivojlanishi bilan aynan dasturni bir platformadan
boshqasiga oson o’tkazish muammosi birinchi rejaga chiqdi. Bu vazifalarni hal etish uchun yangi
til zarur edi va u Java bo’ldi.
Ta’kidlash kerakki, dastlab Java nisbatan oddiy rol o’ynadi. U til platformasiga bog’liq
bo’lmagan, o’rnatilgan kontrollerlar uchun dasturiy ta’minotni yaratishda qo’llash mumkin
bo’lgan vosita tarzida yaratildi. 1993 yilda kichik miqyosda (o’rnatilgan kontrollerlar uchun)
o’tkazuvchanlik muammolarini hal qilish uchun foydalaniladigan texnologiyalar katta miqyosda
(Internet uchun) foydalanilishi mumkinligi ravshan bo’ldi. Java ning eng asosiy imkoniyati –
platformalararo o’tkazish kodini yaratish qobiliyati ushbu tilni tez tarqalishiga sabab bo’ldi.
Java da o’tkazuvchanlik dasturning boshlang’ich kodlarini bayt-kod deb ataladigan oraliq tilga,
keyinchalik Java (Java Virtual Machine, JVM) virtual mashinasi tomonidan bajariladigan
translyatsiya qilish vositasi yordamida erishiladi. Shunday ekan, Java-dasturi JVM ga ega
bo’lgan ixtiyoriy platformada ishga tushirilishi mumkin. JVM nisbatan oson tatbiq etilishi
sababli, u ko’p sonli platformalar uchun mo’ljallangan.
Bayt-koddan Java da foydalanish amalda har doim mashina kodlari tomonidan kompillyatsiya
qilinadigan S va SQQ tillarida kodlarni qo’llashdan keskin farq qiladi. Mashina kodi muayyan
protsessorlar va operatsion tizimlar bilan bog’liq, shunga ko’ra, SG’SQQ-dasturlarini boshqa
platformalarda ishga tushirish uchun dasturning dastlabki kodini bu platformalarning (ya’ni
dasturning bir nechta ijrochi versiyalari bo’lishi kerak) har birini mashina kodiga qayta
kompillyatsiya qilish zarur. Bu ko’p mehnat talab qiladigan va qimmat jarayon ekanligi
tushunarli. Java da esa elegant va samarali qaror – oraliq tillardan foydalanish taklif qilingan. Va
bu qaror keyinchalik C#ga tatbiq etilgan.
YUqorida ta’kidlanganidek, Java mualliflari yangi qarashlari bilan uni S va SQQ (Java sintaksisi
S ga asoslanadi, ob’ekt modeli esa SQQ dan shakllantirilgan ) negizida yaratishdi. Garchi Javakod S yoki SQQ bilan o’zaro muvofiq bo’lmasada, uning sintaksisi mazkur tillar sintaksisidan
kelib chiqqan. Shuning uchun S va SQQ dan foydalanuvchi dastur tuzuvchilarning katta qismi
Java ga ortiqcha qiyinchiliklarsiz o’tishga muvaffaq bo’lishdi. SQQ ishlab chiqishda Straustrap
kabi Java mualliflariga ham mutlaqo yangi tilni yaratish zaruriyati bo’lmadi. Ular asos sifatida
oldin ma’lum bo’lgan tillardan foydalanishdi va diqqatlarini innovatsion elementlarga jamlay
oldilar. Ta’kidlash joizki, Java yaratilganidan keyin S va SQQ tillari yangi kompyuter tillarini
yaratish uchun umumqabul qilingan poydevor bo’lib qoldi.
C# tilining yaratilish tarixi
Garchi Java tili dasturlarni bir platformadan boshqasiga o’tkazishning ko’plab muammosini hal
qilgan bo’lsa ham, zamonaviy Internet-muhitida samarali ishlashi uchun unga bir qator xossalar
yetmayapti. Ulardan biri bir qancha kompyuter tillarini (ko’p tilli dasturlash) o’zaro aloqa
imkoniyatlarini qo’llab-quvvatlash hisoblanadi. Ko’p tilli dasturlash deganda turli tillarda
yozilgan kodning birgalikda ishlash qobiliyati tushuniladi. Bu imkoniyat katta dasturlarni
yaratishda, shuningdek ko’plab kompyuter tillarida va turli xil operatsion muhitlarda foydalanish
mumkin bo’lgan alohida komponentlarni dasturlashda juda muhimdir.
Windows platformalarini to’g’ridan-to’g’ri qo’llab-quvvatlashning yo’qligi Java ning jiddiy
kamchiligi hisoblanadi (Garchi, Java-dasturlari Windows muhitida installirlashgan JVM
mavjudligida bajarishi mumkin bo’lsa ham).
Ushbu muammoni hal etish uchun Microsoft kompaniyasi 1990 yillar oxirida bu kompaniyaning
umumiy strategiyasi .NET ning tarkibiy qismi hisoblangan C#tilini ishlab chiqdi (tilning bosh
me’mori Anders Xeylsberg). Alfa-versiya tili 2000 yil o’rtalaridan muomalaga chiqarila
boshlandi.
C#tili butun dunyoda keng qo’llanilayotgan va eng ommabop bo’lgan S, SQQ va Java dasturlash
tillari bilan to’g’ridan-to’g’ri bog’liqdir. Hozirda amalda barcha professional dastur tuzuvchilar
mazkur tilni biladi, shuning uchun ularga asoslangan C#ga o’tish ortiqcha qiyinchiliklarsiz ro’y
beradi. Xeylsberg, CQQ va Java tillari muallifi sifatida, “g’ildirak kashf” qilmadi, balki kashf
etilgan yo’ldan ketdi – asos sifatida oldin yaratilgan tillardan foydalangan holda e’tiborni
yaxshilash va innovatsiyalarga qaratdi.
C#ning genealogik tasnifi 1.1. rasmda ko’rsatilgan. C#tili SQQ da aniqlagan ob’ektli modelga
qurilgan. Sintaksisi, ko’plab kalit so’zlar va operatorlarni C tilidan meros qilib olgan. Shu
sababli dasturlashning ushbu tillarini bilganlar uchun C#ni o’rganishda hech qanday muammo
kelib chiqmaydi.
C#va Java o’rtasidagi aloqa nisbatan murakkab. Ikkala til ham o’tkazuvchi kodni yaratish uchun
ishlab chiqilgan, C va SQQ larga asoslanadi, ularning sintaksisi va ob’ektli modelidan
foydalanadi. Biroq, mazkur tillar o’rtasida to’g’ridan-to’g’ri aloqa yo’q, ular ko’proq umumiy
ajdodlarga ega, lekin ko’plab belgilari bilan farq qiluvchi amakivachchalarga o’xshaydi. Agarda
siz Java da ishlashni bilsangiz, bu C#ni o’zlashtirishingizni yengillashtiradi, va buning teskarisi,
Java ni o’rganishda C#ning ko’plab konsepsiyalari bilimlari sizga foydasi tegadi.
C#tili mazkur kitobda ko’rib chiqiladigan ko’plab innovatsion xossalarga ega. Birdaniga anglash
mumkinki, uning bir nechta eng muhim yangiliklari dasturiy ta’minlash komponentlarini
o’rnatilgan qo’llab-quvvatlashga taalluqlidir.
YA’ni aslida C#komponentlarga yo’naltirilgan o’zida, masalan, dasturiy ta’minlash
komponentlarining tarkibiy qismlarini bilvosita qo’llab-quvvatlovchi elementlarni (xossa, usul
va hodisalar kabilar) qamrab oluvchi til sifatida yaratilgan.
Lekin, ehtimol, C#ning eng muhim yangi xususiyati – bu uning ko’p tilli muhitda ishlash
qobiliyatining mavjudligidir.
S
SQQ
Java
C#
1– rasm. C#ning genealogik tasnifi
C#ning .NET Framework bilan aloqasi
Garchi C#dasturlash tili sifatida alohida o’rganilishi mumkin bo’lsada, lekin uni o’zi ishlaydigan
.NET Framework-muhiti bilan o’zaro aloqasini ko’rib chiqish afzalroqdir. Chunki, birinchidan,
C#dastlab Microsoft kompaniyasi tomonidan .NET Framework kodini yaratish uchun ishlab
chiqilgan, ikkinchidan, .NET Framework C#tili tomonidan foydalaniladigan kutubxonani aniqlab
beradi. Modomiki ular bunday chambarchas bog’liq ekan, .NET Framework ning umumiy
konsepsiyasini va uning C#uchun ahamiyatini tushunish muhimdir.
.NET Framework o’zi nima?
Sarlavhada berilgan savolga javob berish, aftidan, .NET Framework deb platforma mustaqil
izohlarni rivojlantirish va bajarishni qo’llab-quvvatlovchi muhitni talqin qilsa bo’ladi. U
dasturlashning turli tillari izohlarida birgalikda ishlash imkonini beradi, shuningdek Windows
uchun umumiy dasturlash modellari va dasturlar o’tkazuvchanligini ta’minlaydi. Ta’kidlash
kerakki, .NET Framework Windows platformasi tomonidan chegaralanmagan va ushbu
platforma uchun yozilgan dasturlar kelajakda boshqa platformaga o’tkazilishi mumkin.
C#tili .NET Framework ning ikki muhim tashkil etuvchilaridan foydalanadi. Birinchi – bu
tilning ijro etish muhitiga bog’liq bo’lmagan (Common Language Runtime, CLR), sizning
dasturlaringiz ijrosini boshqaruvchi va .NET Framework texnologiyasining bir qismi
hisoblanuvchi tizim, qaysiki dasturlarga o’tuvchan bo’lish imkonini beradi, bir qancha tillardan
foydalanish bilan dasturlashni qo’llab-quvvatlaydi va ma’lumotlarni uzatish xavfsizligini
ta’minlaydi.
Ikkinchi tashkil etuvchi - dasturlarga ijro muhitiga kirish imkonini beruvchi .NET sinflar
kutubxonasidir, masalan, ma’lumotlarni kiritishG’chiqarish uchun foydalaniladi. Agar siz
endigina boshlagan dastur tuzuvchi bo’lsangiz, unda sizga sinf tushunchasi notanish bo’lishi
mumkin. Sal quyida biz sinflar to’g’risida batafsil to’xtalib o’tamiz, hozir shunchaki uqtirib
o’tamizki, sinflar dasturlarni tashkillashtirishga yordam beruvchi ob’ektga yo’naltirilgan
konstruksiya hisoblanadi. Hozircha sizning dasturingiz xususiyatlar, .NET sinflarining muayyan
kutubxonasi bilan chegaralangan bo’lsa, u .NET ijro muhiti qo’llab-quvvatlanadigan barcha
joyda ishlatilishi mumkin.
Bajarilish muhiti tiliga bog’liq bo’lmagan qanday ishlaydi
.NET kodi bajarilishi bilan tilga bog’liq bo’lmagan bajarilish muhiti (CLR) boshqaradi. U
qanday ishlashini bayon qilamiz. C#dasturini kompilyatsiya qilganda, biz bajariladigan kodni
emas, Microsoftning oraliq tili deb ataluvchi (Microsoft Intermediate Language, MSIL) maxsus
psevdokoddan tashkil topgan faylni olamiz. MSIL tili konkret protsessorga bog’liq bo’lmagan
tashiladigan ko’rsatmalar to’plamini aniqlaydi, ya’ni, mohiyati bo’yicha, MSIL tashiladigan
assembler tilini aniqlaydi. Oraliq Microsoft tili mazmunan Java bayt-kodiga o’xshashligiga
sizning diqqatingizni qaratmoqchimiz, ammo ularning orasida farq bor.
CLR tizimi oraliq kodni bajariladigan kodga dastur ishga tushirilgan vaqtda translyatsiya qiladi.
MSILda kompilyatsiya qilingan ixtiyoriy dastur CLR muhiti realizatsiya qilingan ixtiyoriy
operatsion tizimda ishga tushirilishi mumkin. Bu .NET Frameworkda dasturlarning
tashiluvchanligiga erishilishiga yordam beradigan mexanizmning bir qismidir.
Oraliq Microsoft tili JIT kompilyatoridan foydalanilganda bajariladigan kodga aylanadi (ingl.
just in time –kerakli vaziyatda) . Jarayon quyidagicha ishlaydi: .NET dasturi bajarilganda CLR
tizimi JIT kompilyatorini faollashtiradi, qaysiki u MSIL ni mazkur protsessorning ichki kodiga
aylantiradi, u ham bo’lsa dastur qismlarining kodlari ehtiyoj bo’lgandagina imkon darajasida
aylantiriladi. Shunday qilib, sizning C# dasturingiz aslida ichki kod sifatida ijro etiladi, garchi u
azaldan MSILda kompilyatsiya qilingan bo’lsada. Bu degani, sizning dasturingizni ishga tushish
vaqti amalda xuddi uning birdaniga ichki kodga kompilyatsiya qilinganiday, ammo bunda sizda
MSILning ustunligi - dasturning tashiluvchanligi paydo bo’ladi. Bundan tashqari, C#dasturini
kompilyatsiya qilganda MSILga qo’shimcha siz yana bitta berilganlarni tasvirlaydigan,
dasturingiz tomonidan ishlatiladigan va sizning kodingizga boshqa kod bilan o’zaro ta’sir
qiladigan-metama’lumot komponentani olasiz. Metama’lumotlar MSIL joylashgan fayllarda
saqlanadi. Aslida bu CLR muhiti, MSIL va metama’lumotlar to’g’risidagi bilimlar C#tilida
dasturlash masalasining asosiy qismini realizatsiyasi uchun yetarli, qaysiki bu til ishni kerakli
tarzda mustaqil ravishda tashkil qiladi.
Tilning umumiy spesifikatsiyasi
Boshqariladigan kodning barcha ustunliklari CLR tomonidan ta’minlanadi. Agar sizning
kodingiz boshqa tillarda yozilgan dasturlar tomonidan foydalanilsa, maksimal mos kelishligi
uchun tilning umumiy spesifikatsiyasiga asoslanish zarur(Common Language Specification,
CLS). Bu har xil tillar uchun umumiy bo’lgan xususiyatlar to’plamini tasvirlaydi. Umumiy til
spesifikatsiyasi kodining mosligi ayniqsa boshqa tillar tomonidan foydalaniladigan dastur
ta’minoti komponentalarini hosil qilish uchun kerak bo’ladi. Agar siz kelajakda tijorat kodini
yaratmoqchi bo’lsangiz, u holda CLS spesifikatsiyasiga asoslanishingizga to’g’ri keladi. Shuning
uchun biz, garchi buning kitobimizga bevosita aloqasi bo’lmasada, bu bo’limda u haqida
ma’lumotlar keltirdik.
Mutaxassis javoblari
Savol. Nima uchun bir nechta tillardan foydalangan holda tashish masalalari, xavfsizlik va
dasturlash tomonlarini hal qilish uchun C#kompyuter tilini yaratish kerak bo’ldi? CQQ tilini
.NET Framework ni qo’llash uchun soddalashtirish mumkin emasmidi?
Javob. Ha, CQQ tilini shunday soddalashtirish mumkinki, natijada u CLR muhiti boshqaruvida
ishga tushiriladigan .NET ga mos keladigan kodni hosil qilsin. Dastlab Microsoft kompaniyasi
shunday ham qildi, mavjud kodlarni .NET Framework ga o’tkazish imkoniyatini beradigan,
hamda boshqariladigan kengaytmalar deb ataladiganlarni CQQ ga qo’shib qo’ydi. Ammo yangi
.NET ishlanmasi buni C#da ancha yengil bajarishga imkon beradi. Esingizdami, C# tili aynan
.NET platformasi uchun yaratilgan va bu texnologiyaning rivojlanishini qo’llash uchun
mo’ljallangan edi.
Minutlik amaliyot
1. C#tilining qaysi tillar bilan bevosita aloqasi bor?
2. Tilga bog’liQ bo’lmagan bajarilish muhiti (CLR) nima?
3. JIT-kompilyator nima?
Ob’ektga-yo’naltirilgan dasturlash
S# tili ob’ektga-yo’naltirilgan dasturlash (OYD) prinsiplariga asoslanadi va barcha Qo’shimcha
dasturlar (Soprogrammo’) Qaysidir darajada ob’ektga-yo’naltirilgan bo’lib hisoblanadi. Shuning
uchun hattoki, eng oddiy Si – dasturini yozish uchun OYD prinsiplarini bilish lozim.
OYD dasturchilar duch keladigan masalalarni yechishning zo’r texnologiyasi bo’lib hisoblanadi.
Kompyuter kashf Qilinishi bilan dasturlash usullari sezilarli darajada o’zgardi. Kompyuter
fanlarining rivojlanishi mobaynida
____________________________________________________________
1.
S# tili S va CQQ larning avlodi bo’lib hisoblanadi, shu bilan birga Java bilan ham
yaQinligi bor.
2.
.NET dasturi bajarilishi bilan tilga bog’liQ bo’lmagan bajarilish muhiti (CLR)
boshQaradi
3.
JIT-kompilyatori MSlL-kodni mazkur protsessorning ichki kodlariga almashtiradi,
shuningdek, dastur Qismlarining kodlari ham ehtiyoga ko’ra almashtiriladi.
mutaxassislarga asosan dasturlarni murakkabligini oshishi bilan bog’liQ masalalarni hal Qilishga
to’g’ri keldi. Masalan, birinchi kompyuterlarda dasturlash ikkilamchi mashina instruksiyalarini
o’zgartirish vositasida amalga oshirilgan, shuning uchun kompyuterning oldingi panelini
boshQarish elementlari foydalanilgan. Ushbu usul dasturlar hajmi bir necha yuzlab instruksiyalar
bilan chegaralangan holatgacha yaxshi ishladi. Foydalaniladigan kodlar hajmi o’sganda
assembler tili kashf Qilindi va dastur tuzuvchilar mashina instruksiyalaridan ramziy ma’noda
foydalanish Qatorida endi nisbatan murakkab va katta dasturlar bilan ishlash imkoniga ega
bo’ldilar. Keyin dasturlar hajmi va murakkabligining o’sishiga mos ravishda dastur tuzuvchilar
FORTRAN va COBOL kabi yuQori darajadagi tillarni ishlab chiQishdi. Oldingi tillar
o’zlarining imkoniyatlari chegarasiga yetganda esa strukturaviy dasturlash yaratildi.
E’tibor bering, dasturlash rivojlanishining har bir bosQichida dastur tuzuvchiga nisbatan
murakkab vazifalarni hal Qilish imkonini beruvchi texnologiya va instrumentlar yaratilgan. Bu
yo’ldagi har bir Qadamda yangi texnologiyalar oldingilarining eng yaxshi jihatlarini o’ziga
olishgan. Vaziyat shu darajaga bordiki, ko’plab loyihalar strukturaviy dasturlash o’sha davr
talablariga nomuvofiQ bo’lib Qolgan chegaraga yetib keldi va umuman yangi istiQbolli, Qaysiki
ob’ektga-yo’naltirilgan dasturlash bo’lgan texnologiyalarga zarurat tug’ildi.
OYD o’zida strukturaviy dasturlashning eng yaxshi g’oyalarini singdirib oldi va ularni oQibatda
dasturlarni tashkillashtirishning yangi yo’llari paydo bo’lishiga olib kelgan bir nechta yangi
konsepsiyalar bilan birlashtirdi. Masalaga chuQur yondoshmasdan shuni aytish mumkinki,
dastur ikkita usuldan bittasi orQali tashkil topadi: o’zining kodi atrofida yoki o’zining
ma’lumotlari atrofida. Strukturaviy dasturlash texnologiyalaridan foydalanishda odatda dasturlar
kod atrofida tashkillashtiriladi. Bunday usulga “ma’lumotlarga ta’sir etuvchi kod” deb Qarash
mumkin.
OYD dasturlari boshQacha usullar bilan ishlaydi. Ular ma’lumotlar atrofida tashkillashtirilgan va
ularning hal Qiluvchi prinsipini “boshQariladigan ma’lumotlar orQali kodga kirish” deb
ifodalash mumkin. Ob’ektga-yo’naltirilgan tillarda siz ma’lumotlarni, shuningdek bu
ma’lumotlarga ta’sir etishi mumkin bo’lgan protseduralarni (ya’ni aynan ma’lumotlar tipi ushbu
ma’lumotlarga Qo’llanilishi mumkin bo’lgan operatsiyalar shaklini belgilab beradi) aniQlaysiz.
OYD ning barcha tillaridagi, S# ham Qo’shib hisoblaganda, ob’ektga-yo’naltirilgan dasturlash
prinsiplarini Qo’llab-Quvvatlash uchun uchta umumiy jihatlar mavjud - inkapsulyatsiya, ko’p
shakllilik (polimorfizm) va vorislik.
Keling, ularni alohida-alohida ko’rib chiQamiz.
Inkapsulyatsiya
Inkapsulyatsiya —bu kod va berilganlarni bir butun Qilib bog’laydigan, ularni manipulyatsiya
Qiluvchi, shu bilan birga ularni tashQi kirishlardan va noto’g’ri Qo’llashdan muofaza Qiluvchi
dasturlash mexanizmi bo’lib hisoblanadi. Ob’ektga-yo’naltirilgan tilda kod va barcha zarur
ma’lumotlar shunday usul bilan bog’lanishi mumkinki, bunda ob’ekt ko’rinishidagi- avtonom
struktura tashkil topadi. BoshQacha Qilib aytganda, inkapsulyatsiyani Qo’llab Quvvatlaydigan
strukturaga ob’ekt deb ataladi.
Ob’ekt chegarasida kod, ma’lumotlar yoki kod ham, ma’lumotlar ham boshQa ob’ektlar uchun
yopiQ (private), yoki ochiQ bo’lishi mumkin (public).
Kod va ma’lumotlarni yopilishi faQat shu ob’ektning boshQa Qismidan ma’lum va o’rinli
bo’ladi (ya’ni yopiQ kodga va ma’lumotlarga shu ob’ekt tashQarisidan kirish mumkin emas).
Qachonki kod va ma’lumotlar ochiQ bo’lsa (biror ob’ekt miQyosida public singari e’lon
Qilingan), dasturning boshQa Qismlari ham ular bilan ishlash imkoniyatiga ega bo’ladi. Odatda
public sifatida e’lon Qilingan ob’ekt Qismlari, nazorat Qilinadigan interfeysni ob’ektning yopiQ
elementlari bilan ta’minlash uchun foydalaniladi.
Sinf S# da inkapsulyatsiyada foydalaniladigan, ma’lumotlarni va mazkur ma’lumotlar bilan
ishlovchi kodlarni ixtisoslashtiruvchi asosiy struktura bo’lib hisoblanadi. S# tili ob’ektlarning
loyihasi uchun sinflarning namunalari hisoblangan tasniflangan sinflarni Qo’llaydi. Shunga
ko’ra, sinf aslida ob’ektlar Qanday tashkil etilishi ko’rsatilgan instruksiyalar to’plami
hisoblanadi.
Kod va ma’lumotlar sinfini tashkil etuvchilar sinf a’zosi deb ataladi, muayyan sinf tomonidan
aniQlangan ma’lumotlar esa o’zgaruvchan namunalar deb nomlanadi. Mazkur ma’lumotlar bilan
ishlovchi kod fragmentlari sinf a’zosi usullari yoki shunchaki, usullar deb ataladi. S# da usul
tushunchasi dasturostilar uchun Qabul Qilingan, Qaysiki SG’S-*-Q da dastur tuzuvchilar
funksiya deb ataydi (modomiki S# CQQ ning to’g’ridan-to’g’ri merosxo’ri hisoblanar ekan,
ba’zan funksiya tushunchasi ham ishlatiladi).
Polimorfizm
Polimorfizm (yunonchadan olingan bo’lib, “shakllar to’plami” degan ma’noni anglatadi) bir
Qator umumiy xossalarga ega bo’lgan bir necha ob’ektlarga bitta interfeysga kirish va unda
nazarda tutilgan usullarni amalga tatbiQ etish imkonini beradigan xususiyat hisoblanadi. Oddiy
misol sifatida avtomobil rulini ko’rib chiQamiz. Rul (interfeys) rul mexanizmning Qanday xili
Qo’llanilishidan Qat’i nazar o’zgarmasdan Qoladi. YA’ni, rulning ishlash prinsipi garchi
avtomobilda Qo’lda boshQarish yoki kuchaytirgichli rul boshQaruvi o’rnatilgan bo’lsa ham har
doim o’zgarishsiz Qoladi (masalan, rul g’ildiragining chapga burilishi avtomobilni ham chapga
burilishiga olib keladi). Unifikatsiyalangan interfeysning afzalligi shundaki, agarda siz bir marta
avtomobil boshQarishni o’rgansangiz, u holda har QanaQa tipdagi avtomobilni boshQara olasiz.
Xuddi shu prinsipni dasturlashga ham tatbiQ etsa bo’ladi. Masalan, stek – LIFO (last in, first
out) ro’yxat tipi. Siz turli xildagi uchta stek talab Qiladigan (bittasi son bilan ifodalanadigan
Qiymatlar uchun, bittasi suzuvchi nuQtali Qiymatlar uchun, va bittasi belgilar uchun) dastur
bilan ishlashingiz mumkin. Ushbu holatda har bir stekni tatbiQ etish uchun saQlanayotgan
ma’lumotlar har xil bo’lsa ham bitta va o’sha algoritm ishlatiladi. Ob’ektga-yo’naltirilgan tildan
tashQarida sizga uchta har bir to’plamga alohida nom bilan turli xil steklar protsedurasi
to’plamini yaratish kerak bo’ladi. Shunday yo’l bilan, stekning bir tipidan foydalanish usullarni
aniQlash orQali siz uni Qolgan tiplarga Qo’llashingiz mumkin bo’ladi.
Polimorfizm konsepsiyasining umumlashmasini Quyidagi ta’riflash mumkin: “bir interfeys –
usullar to’plami”. Bu o’xshash jarayonlar guruhlari uchun unifikatsiyalangan interfeys yaratish
mumkinligini anglatadi. Polimorfizm dasturlar murakkabligini umumiy harakat sinflari
spesifikayasi uchun yagona interfeysdan foydalanish orQali kamaytirish imkonini beradi. Har bir
vaziyatga tatbiQan kompilyatorning o’zi sizni bu harakatlarni Qo’lda Qilish zaruratidan xalos
Qilgan holda spesifik harakatlar (ya’ni usul)ni tanlaydi. Siz faQat mazkur interfeysda Qaysi
usullar nazarda tutilganligini va ularni amalga tatbiQ etishni esdan chiQarmasligingiz kerak.
Vorislik - ob’ektiv yo’naltirilgan programmalashni uchta fundamental prinsiplaridan biridir,
chunki faqat shu bilan birga ierarxik klassifikatsiya tuzish mumkin. Vorislikdan foydalangan
holda o’zaro bog’liq elementlarni harakteristikasini belgilovchi umumiy sinf xosil qilish
mumkin. Bu sinf o’ziga xos yagona xususiyatga ega tor mutaxassislashtirilgan sinflar qoldirishi
mumkin.
S# tilida bu sinf baza sinfi deb ataladi. Baza sinfidan hosila sinfi kelib chiqadi. Binobarin, hosila
sinfi – bu baza sinfining maxsus talqinidir. Hosila sinfiga baza sinfidagi mavjud metodlar va
indeksatorlardan tashqari o’ziga xos yagona elementlar ham qo’shilishi mumkin.
Vorislik asoslari.
C# vorislikni qo’llab, bildirilgan sinfni boshqa sinfga o’rnatishga yo’l beradi. Bu baza sinfi
masalalarini berilgan hosila sinfi orqali amalga oshirish mumkin. Buni misollar orqali ko’rish
qulaydir. Umumlashtirilgan ikki o’lchamli geometrik figuralar (masalan, kvadrat, to’g’ri
burchak, uchburchak va boshqalar) atributlarini belgilovchi TwoDShare sinfini ko’rib chiqamiz.
G’G’ Klass dvumerno’x ob’ektov.
class TwoDShape {
public double width;
public double height;
public void showDim( ) {
Console.WriteLine ("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
TwoDShare sinfi ikki o’lchamli ob’eklarning maxsus shakllarini tasvirlashda o’z navbatida
boshqa sinflar uchun baza sifatida qo’llanishi mumkin. Masalan, TwoDShare sinfini navbatdagi
programmasi Triangle sinfini boshqarish uchun qo’llaniladi.
G’G’ Prostaya ierarxiya klassov.
using System;
G’G’ Klass dvumerno’x ob’ektov.
class TwoDShape {
public double width;
public double height;
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height); }
}
G’G’ Klass Triangle vo’voditsya iz klassa TwoDShape.
class Triangle : TwoDShape {
public string style; G’G’ Tip treugolnika.
G’G’ Metod vozvrahaet plohad treugolnika,
public double area() {
return width * height G’2;
}
G’G’ Otobrajaem tip treugolnika.
public void showStyle() {
Console.WriteLine("Treugolnik " Q style);
}
}
class Shapes {
public static void Main() {
Triangle t1 q new Triangle();
Triangle t2 q new Triangle();
t1.width q4.0;
t1.height q 4.0;
t1.style q "ravnobedrenno’y";
t2.width - 8.0;
t2.height q12.0;
t2.style q "pryamougolno’y";
Console.WriteLine("Informatsiya o t1: ");
tl.showStyle() ;
tl.showDim() ;
Console.WriteLine("Plohad ravna " Q t1.area());
Console.WriteLine();
Console.WriteLine("Informatsiya o t2: ");
t2. ShowStyle() ;
t2. showDim() ;
Console.WriteLine("Plohad ravna " Q t2.area());
}
}
Triangle sinfida TwoDShare sinfiga mansub bo’lgan ob’ektni maxsus shakli tashkil etiladi,
masalan, uchburchak. Triangle sinfida TwoDShare sinfidagi elementlardan tashqari Style, area
va showstyle elementlarini o’z ichiga oladi. O’zgaruvchan style uchburchak shaklini tasvirlashni
saqlaydi, area() usul uning yuzasini aniqlaydi, showStyle() usuli esa berilgan uchburchak
shaklini aks ettiradi. Quyida Triangle sinfini TwoDShape sinfidan hosila sifatida qo’llanishi
sintaksisi keltirilgan:
Class Triangle : TwoDShape
Agar bir sinf boshqasini qoldirsa, u holda baza sinfini nomi hosila sinfini nomidan keyin
ko’rsatiladi va sinflar nomi ikki nuqta bilan ajratilib ko’rsatiladi. C# da sinflarni sintaksis
vorisligi eslab qolish va qo’llash uchun juda oddiydir.
Triangle sinfi TwoDShape baza sinfini barcha a’zolarini kiritadi va width va height a’zolarini
area () usuli ichida ishlatishi mumkin. Bundan tashqari, Main () usuli ichida t1 va t2 ob’ektlar
Triangle sinfini qismi bo’lsa, width va height a’zolarida to’g’ridan-to’g’ri izohlanishi mumkin.
Triangle sinfini TwoDShape sinfiga qo’shilishi quyidagi rasmda sxematik tarzda keltirilgan.
Width
TwoDShape
Height
ShowDim()
Tringle
Style
Area
ShowStyle()
TwoDShape sinfi Triangle sinfi uchun baza sinfi bo’lib, bu butunlay mustaqil va avtonom
sinfdir.
Hosila sinfini yaratishda faqat bitta baza sinfini ko’rsatish mumkin. C# da (C dan farqli) bitta
hosila sinfida bir nechta baza sinflari vorislikni ta’minlamaydi. Bu faktni C kodni C# ga
o’tkazishda bilish kerak. Bir hosila sinfi boshqa hosila sinfiga baza bo’lganligidan bir ierarxiya
vorislikni yaratish mumkin. Lekin bitta sinf o’ziga –o’zi baza sinfi bo’lishi mumkin emas.
Vorislikning asosiy xususiyati shundaki,ko’p ob’ektlar uchun umumiy atributlarni aniqlovchi
baza sinfini hoxlagan sondagi maxsus hosila sinflarini yaratish uchun qo’llash mumkin. Keyin
har bir hosila sinfi uchun xususiy klassifikatsiya yaratish mumkin. Masalan, twoDShape sinfi
baza sifatida hosila sinfini yaratishi mumkin.
Vorislik va sinf a’zolariga kirish xuquqi
Vorislik yopiq kirish xuquqiga bog’liq chegaralarni bekor qilmaydi. Shuning uchun xosila sinf
baza sinfni yopiq deb e’lon qilingan a’zolariga kirish xuquqidan maxrum bo’ladi. Masalan,
keyingi kodda ko’rsatishicha, agar width va height a’zolari TwoDShape sinfini private a’zosini
hosil qilsa, u holda Triangle sinfi unga kirish xuquqiga ega emas.
G’G’ Dostup k zakro’to’m chlenam ne nasleduetsya.
G’G’ Etot primer ne skompiliruetsya.
using System;
G’G’ Klass dvumerno’x ob’ektov,
class TwoDShape {
double width; G’G’ Teper eto private-chlen.
double height; G’G’ Teper eto private-chlen.
public void showDim( ) {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass Triangle vo’voditsya iz klassa TwoDShape.
class Triangle : TwoDShape {
public string style; G’G’ Tip treugolnika.
G’G’ Metod vozvrahaet znachenie plohadi treugolnika.
public double area ( ) {
return width * height G’ 2; G’G’ Oshibka, nelzya poluchit
G’G’ pryamoy dostup k zakro’to’m
G’G’ chlenam.
G’G’ Otobrajaem tip treugolnika.
public void showStyle( ) {
Console.WriteLine ("Treugolnik " Q style);
}
}
width va height – yopiq a’zolardir, ular faqat xususiy sinf a’zolari uchun kirish xuquqiga ega.
Hosila sinfida esa bu xuquq tarqalmagan.
Shunga qaramay S# da bu muammoni yechish imkoniyatlari mavjud. Bulardan biri – protected
a’zolardir, ikkinchisi ochiq usul va turlardan foydalangan xolda yopiq ma’lumotlarga kirishdir:
G’G’ Ispolzovanie svoystv dlya zapisi i chteniya zakro’to’x
G’G’ chlenov klassa.
using System;
G’G’ Klass dvumerno’x ob’ektov.
class TwoDShape {
double pri_width; G’G’ Teper eto private-chlen.
double pri_height; G’G’ Teper eto private-chlen.
G’G’ Svoystva width i height.
public double width {
get { return pri_width; }
set { pri_width q value; }
}
public double height {
get { return pri_height; }
set ( pri_height q value; }
}
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass treugolnikov - proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
public string style; G’G’ Tip .treugolnika.
G’G’ Metod vozvrahaet znachenie plohadi treugolnika.
public double area() {
return width * height G’ 2;
}
G’G’ Otobrajaem tip treugolnika.
public void showStyle() {
Console.WriteLine("Treugolnik " Q style);
}
}
class Shapes2 {
public static void Main ( ) {
Triangle t1 q new Triangle ( );
Triangle t2 q new Triangle ( );
t1.width q 4.0;
t1.height q 4.0;
t1.style q "ravnobedrenno’y";
t2.width q 8.0;
t2.height q 12.0;
t2.style q "pryamougolno’y";
Console.WriteLine("Informatsiya o t1: ");
t1.showStyle ( ) ;
t1.showDim ( ) ;
Console.WriteLine("Plohad ravna " Q t1.area());
Console.WriteLine();
Console.WriteLine("Informatsiya o t2: ");
t2.showStyle ();
t2.showDim ();
Console.WriteLine("Plohad ravna " Q t2.area());
}
}
Baza va xosila sinflari bu holda superklass va podklass deb ataladi. Bu terminlar Java dasturlash
tilidan olingan bo’lib, superklass- bu S# da baza sinfi, podklass- bu C# da hosila sinfi. S da
ham «baza sinf  hosila sinf» terminlari qo’llaniladi.
Ximoyalangan kirish xuquqidan foydalanish.
Baza sinfini yopiq a’zolari hosila sinfi uchun kirish xuquqiga ega emas. Agar hosila sinfi baza
sinfi a’zolariga kirish xuquqiga ega bo’lsa, u holda u ochiq bo’lishi kerak.
Baza sinfini a’zolarini yopiq tutgan xolda, unga xosila sinfiga kirish xuquqini ximoyalangan
a’zolar yordamida berish mumkin. Ximoyalangan a’zo o’z ierarxiyasida barcha sinflarga ochiq
bo’ladi.
Ximoyalangan a’zo protected kirish modifikatori yordamida tashkil etiladi. Protected a’zoda
yopiq bo’ladi, lekin himoyalangan a’zo vorislik qoldirsa, bu rad etiladi. Bunday holda baza
sinfini himoyalangan a’zosi hosila sinfini himoyalangan a’zosiga aylanadi, natijada hosila sinfi
uchun kirish xuquqiga ega bo’ladi. Bunda protected kirish modifikatori yopiq a’zolarni hosil
qilishi mumkin, shu bilan birga hosila sinfi uchun kirish imkoniyatini yaratadi.
Sinfning himoyalangan a’zolarini qo’llanishini oddiy misolda ko’rib chiqamiz:
G’G’ Demonstratsiya ispolzovaniya zahihenno’x chlenov klassa.
using System;
class V {
protected int i, j; G’G’ Zakro’t vnutri klassa V,
G’G’ no dostupen dlya klassa D.
public void set(int a, int b) {
i q a;
j q b;
}
public void show() {
Console.WriteLine(i Q " " Q j);
}
}
class D : V {
int k; G’G’ Zakro’to’y chlen.
G’G’ Klass D poluchaet dostup k chlenam i i j klassa V.
public void setk() {
k q i * j;
}
public void showk() { Console.WriteLine(k);
}
}
class ProtectedDemo {
public static void Main ( ) {
D ob q new D( );
ob.set(2, 3); G’G’ OK, tak kak D "vidit" V-chleno’ i i j.
ob.show(); G’G’ OK, tak kak D "vidit" V-chleno’ i i j.
ob.setk(); G’G’ OK, tak kak eto chast samogo klassa D.
ob.showk( ); G’G’ OK, tak kak eto chast samogo klassa D.
}
}
Konstruktorlar va vorislik.
Sinflar ierarxiyasi o’z konstruktorlari mavjud bo’ladi. Shu bilan birga ob’ektni bazaviy qismini
baza sinf konstruktori tashkil qiladi, xosila qismini – xosila sinfi konstruktori tashkil qiladi.
Chunki baza sinfi hosila sinf elementlariga kirish xuquqiga ega emas. Shuning uchun ularning
konstruksiyalari alohida bo’lishi kerak.
Agar konstruktor faqat hosila sinfida aniqlansa, ob’ektni hosil bo’lish jarayoni juda sodda: hosila
sinfi ob’ekti hosil bo’ladi xolos. Baza sinfiga bog’liq bo’lgan ob’ektni qismi esa konstruktori
yordamida avtomatik hosil qilinadi. Masalan, konstruktorni aniqlashda Triangle sinfini qayta
ishlangan talqinini ko’rib chiqamiz.
G’G’ Dobavlenie konstruktora v klass Triangle.
using System;
G’G’ Klass dvumerno’x ob’ektov. class TwoDShape {
double pri_width; G’G’ Zakro’to’y chlen.
double pri_height; G’G’ Zakro’to’y chlen.
G’G’ Svoystva width i height.
public double width {
get ( return pri_width; }
set ( pri_width - value; }
}
public double height {
get ( return pri_height; }
set ( pri_height q value; }
}
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass treugolnikov - proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor.
public Triangle(string s, double w, double h) {
width q w; G’G’ Initsializiruet chlen bazovogo klassa.
height q h; G’G’ Initsializiruet chlen bazovogo klassa.
style q s; G’G’ Initsializiruet chlen svoego klassa.
}
G’G’ Metod vozvrahaet znachenie plohadi treugolnika.
public double area ( ) { return width * height G’ 2;
}
G’G’ Otobrajaem tip treugolnika.
public void showStyle ( ) {
Console.WriteLine ("Treugolnik " Q style);
}
}
class Shapes3 {
public static void Main ( ) {
Triangle t1 q new Triangle ("ravnobedrenno’y",
4.0, 4.0);
Triangle t2 q new Triangle("pryamougolno’y",
8.0, 12.0);
Console. WriteLine ("Informatsiya o t1: ");
t1.showStyle ( );
t1.showDim ( ) ;
Console.WriteLine ("Plohad ravna " Q t1.area ( ) );
Console.WriteLine ();
Console.WriteLine("Informatsiya o t2: ");
t2.showStyle ( );
t2.showDim();
Console.WriteLine ("Plohad ravna " Q t2.area ( ));
}
}
Agarda konstruktorlar baza va xosila sinflarida tengdan belgilangan bo’lsa, ob’ektni tashkil etish
jarayoni birmuncha murakkabroq kechadi. Bu holda S# base kalit so’zidan foydalanish kerak
bo’ladi.
Baza sinfini konstruktori chaqirish
Xosila sinfi o’zining baza sinfidagi konstruktorni xosila sinfdagi konstruktorni kengaytirilgan
shaklidan va base so’zidan foydalangan xolda chaqirishi mumkin.
G’G’ Dobavlenie konstruktorov v klass TwoDShape.
using System;
G’G’ Klass dvumerno’x ob’ektov.
class TwoDShape {
double pri_width; G’G’ Zakro’to’y chlen.
double pri_height; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor klassa TwoDShape.
public TwoDShape(double w, double h) {
width q w;
height q h;
}
G’G’ Svoystva width i height.
public double width {
get { return pri_width; }
set { pri_width q value; }
}
public double height {
get {return pri_height;}
set {pri_height q value;}
}
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass treugolnikov, proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’G’ Vo’zo’vaem konstruktor bazovogo klassa.
public Triangle(string s,
double w,
double h) : base(w, h) {
style q s;
}
G’G’ Metod vozvrahaet plohad treugolnika.
public double area () {
return width * height G’ 2;
}
G’G’ Otobrajaem tip treugolnika.
public void showStyle() {
Console.WriteLine("Treugolnik " Q style);
}
}
class Shapes4 {
public static void Main( )
Triangle t1 q new Triangle ("ravnobedrenno’y", 4.0, 4.0);
Triangle t2 q new Triangle ("pryamougolno’y", 8.0, 12.0);
Console.WriteLine("Informatsiya o t1: ");
t1.showStyle ( ) ;
t1.showDim();
Console.WriteLine ("Plohad ravna " Q t1.area ( ));
Console.WriteLine ( );
Console.WriteLine ("Informatsiya o t2: ");
t2.showStyle ( );
t2.showDim ( );
Console.WriteLine("Plohad ravna " Q t2.area());
}
}
Bu yerda Triangle konstruktori w va h parametrli base uslubini chaqiradi, xaqiqatda esa bu wight
va height xususiyatli TwoDShape konstruktoridir. Ushbu xususiyatlarni Triangle konstruktori
TwoDShape konstruktoridan olib o’zi fakat style xususiyatini shakllashtiradi xolos.
G’G’ Dobavlyaem v klass TwoDShape konstruktoro’.
using System;
class TwoDShape {
double pri_width; G’G’ Zakro’to’y chlen.
double pri_height; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public TwoDShape() {
width q height q 0.0;
}
G’G’ Konstruktor klassa TwoDShape s parametrami.
public TwoDShape(double w, double h) {
width q w;
height q h;
}
G’G’ Sozdaem ob’ekt, u kotorogo shirina ravna vo’sote.
public TwoDShape(double x) {
width q height q x;
}
G’G’ Svoystva width i height.
public double width {
get { return pri_width; }
set { pri width q value; }
}
public double height {
get { return pri_height; }
set { pri height q value; }
}
public void showDim ( ) {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass treugolnikov, proizvodno’y ot TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’* Konstruktor po umolchaniyu. On avtomaticheski vo’zo’vaet
konstruktor po umolchaniyu klassa TwoDShape. *G’
public Triangle() {
style q "null";
}
G’G’ Konstruktor, kotoro’y prinimaet tri argumenta.
public Triangle(string s, double w, double h) : base(w, h) {
style q s;
}
G’G’ Sozdaem ravnobedrenno’y treugolnik.
public Triangle(double x) : base(x) {
style q "ravnobedrenno’y";
}
G’G’ Metod vozvrahaet plohad treugolnika.
public double area() {
return width * height G’2;
}
G’G’ Otobrajaem tip treugolnika.
public void showStyle () {
Console.WriteLine("Treugolnik " Q style);
}
}
class Shapes5
public static void Main() {
Triangle t1 q new Triangle();
Triangle t2 q new Triangle("pryamougolno’y", 8.0, 12.0);
Triangle t3 q new Triangle(4.0);
t1 q t2;
Console.WriteLine("Informatsiya o t1: ");
t1.showStyle();
t1.showDim();
Console.WriteLine("Plohad ravna " Q tl.area());
Console.WriteLine();
Console.WriteLine("Informatsiya o t2: ");
t2.showStyle();
t2.showDim();
Console.WriteLine("Plohad ravna " Q t2.area());
Console.WriteLine();
Console.WriteLine("Informatsiya o t3: ");
t3.showStyle () ;
t3.showDim () ;
Console.WriteLine ("Plohad ravna " Q t3.area ( ));
Console.WriteLine ( );
}
}
Ushbu usuldagi dasturni bajarilishi natijasida quyidagi natijaga erishamiz:
Informatsiya o t1:
Treugolnik pryamougolno’y
Shirina i vo’sota ravno’ 8 i 12
Plohad ravna 4 8
Informatsiya o t2:
Treugolnik pryamougolno’y
Shirina i vo’sota ravno’ 8 i 12
Plohad ravna 48
Informatsiya o t3:
Treugolnik ravnobedrenno’y
Shirina i vo’sota ravno’ 4 i 4
Plohad ravna 8
Base-mexanizm konsepsiyasini ko’rib chiqamiz. Base- usul hosila sinfi to’g’ridan-to’g’ri baza
sinfi konstruktorini chaqiradi. Bu holda, base kalit so’zi doimo chaqiriluvchi sinflar ierarxiyasida
turgan baza sinfiga
ishlatiladi. Bu yuqori darajali ierarxiya uchun asoslidir. Baza sinfi konstruktori argumentlarini
berish uchun base-usul argumentlari sifatida ko’rsatish yetarlidir.
Vorislik va ismlarni yashirish
Agar xosila sinf a’zosi ismi baza sinfdagi a’zo ismi bilan bir xil bo’lsa, unda baza sinf a’zosi
xosila sinfida yashirin a’zoga aylanadi. Agar buni ataylab quyilgan bo’lsa, unda xosila bazadagi
a’zo oldiga new so’zi qo’yiladi.
G’G’ Primer sokro’tiya imeni v svyazi s nasledovaniem.
using System;
class A {
public int i q 0;
}
G’G’ Sozdaem proizvodno’y klass.
class V : A {
new int i; G’G’ Etot chlen i skro’vaet chlen i klassa A.
public V(int b) {
i q b; G’G’ Chlen i v klasse V. }
}
public void show() {
Console.WriteLine(
"Chlen i v proizvodnom klasse: " Q i);
}
}
class NameHiding {
public static void Main() {
V ob q new V(2);
ob.show();
}
}
YAshirin ismlarga base so’zi yordamida kirish
base so’zini this ma’noda ham foydalansa bo’ladi. Bu xolda base co’zi quyidagi ma’noda keladi:
base. a’zo
Bu shakl asosan yashirin ismlar foydalangan sinflarda foydalanadi:
G’G’ Ispolzovanie sso’lki base dlya dostupa k skro’tomu imeni.
using System;
class A {
public int i q 0;
}
G’G’ Sozdaem proizvodno’y klass. class V : A {
new int i; II Eta peremennaya i skro’vaet i klassa A.
public B(int a, int b) {
base.i q a; G’G’ Tak mojno obratitsya k i klassa A.
i q b; G’G’ Peremennaya i v klasse V.
}
public void show ( ) {
G’G’ Eta instruksiya otobrajaet peremennuyu i v klasse A.
Console.WriteLine ("i v bazovom klasse: " Q base.i);
G’G’ Eta instruksiya otobrajaet peremennuyu i v klasse V.
Console.WriteLine ("i v proizvodnom klasse: " Q i) ;
}
}
class UncoverName {
public static void Main ( ) {
V ob q new V(1, 2) ;
ob.show ( );
}
}
Ushbu dasturni natijasi quyidagicha ko’rinishda bo’ladi:
i v bazovom klasse: 1
i v proizvodnom klasse: 2
base izoxi yordamida yana yashirin usulni chaqirish mumkin. Misol ko’ramiz:
G’G’ Vo’zov skro’togo metoda.
using System; .
class A (
public int i q 0;
G’G’ Metod show ( ) v klasse A.
public void show ( ) {
Console.WriteLine ("i v bazovom klasse: " Q i);
}
}
G’G’ Sozdaem proizvodno’y klass.
class V : A {
new int i; G’G’ Eta peremennaya i skro’vaet
G’G’ odnoimennuyu peremennuyu klassa A.
public V(int a, int b) {
base.i q a; G’G’ Tak mojno obratitsya k
G’G’ peremennoy i klassa A.
i q b; G’G’ Peremennaya i v klasse V.
}
G’G’ Etot metod skro’vaet metod show(), opredelenno’y v
G’G’ klasse A. Obratite vnimanie na ispolzovanie
G’G’ klyuchevogo slova new.
new public void show() {
base.show();
G’G’ Vo’zov metoda show() klassa A.
G’G’ Otobrajaem znachenie peremennoy i klassa V.
Console.WriteLine("i v proizvodnom klasse: " Q i);
}
}
class UncoverName {
public static void Main() {
V ob q new V (1, 2);
ob.show();
}
}
Dastur natijasi quyidagidan iborat:
i v bazovom klasse: 1
i v proizvodnom klasse: 2
YUqori darajali ierarxiyani tuzish.
Xosila sinf boshqa bir xosila sinfga baza sinfga aylansa bu yuqori darajali ierarxiyaga bo’ladi.
Bu xolatda oxirgi xosila sinf o’zidan oldingi barcha sinflarni xususiyatini o’z ichiga oladi.
Quyidagi keltirilgan ierarxiyada xosila sinfi bo’lmish Triangle sinfi ColorTriangle sinfiga baza
sinf rolini o’ynaydi:
G’G’ Mnogourovnevaya ierarxiya.
using System;
class TwoDShape (
double pri_width; G’G’ Zakro’to’y chlen.
double pri_height; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public TwoDShape() (
width q height q 0.0;
}
G’G’ Konstruktor klassa TwoDShape.
public TwoDShape(double w, double h) {
width q w;
height q h;
G’G’ Konstruktor, sozdayuhiy ob’ekto’, u kotoro’x
G’G’ shirina ravna vo’sote.
public TwoDShape(double x) {
width - height q x;
}
G’G’ Svoystva width i height.
public double width {
get { return pri_width; }
set { pri_width q value; }
}
public double height {
get {return pri_height; }
set { pri_height q value; }
}
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height); }
} G’G’ Klass treugolnikov, proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’* Konstruktor po umolchaniyu. On vo’zo’vaet konstruktor
po umolchaniyu klassa TwoDShape. *G’
public Triangle () {
style q "null";
}
G’G’ Konstruktor s parametrami.
public Triangle(string s, double w, double h) : base(w, h) {
style q s;
}
G’G’ Sozdaem ravnobedrenno’y treugolnik.
public Triangle(double x) : base(x) {
style q "ravnobedrenno’y";
}
G’G’ Metod vozvrahaet znachenie plohadi treugolnika,
public double area() {
return width * height G’ 2;
}
G’G’ Metod otobrajaet tip treugolnika.
public void showStyle() {
Console.WriteLine("Treugolnik " Q style);
}
}
G’G’ Prodoljaem ierarxiyu klassov treugolnikov.
class ColorTriangle : Triangle { string color;
public ColorTriangle(
string c, string s,
double w, double h) : base(s, w, h) {
color q c;
}
G’G’ Metod otobrajaet svet treugolnika.
public void showColor() {
Console.WriteLine("Svet " Q color); }
}
}
class Shapes6 {
public static void Main () {
ColorTriangle t1 q
new ColorTriangle("siniy", "pryamougolno’y",
8.0, 12.0);
ColorTriangle t2 q
new ColorTriangle("krasno’y", "ravnobedrenno’y",
2.0, 2.0) ;
Console.WriteLine("Informatsiya o t1: ");
t1.ShowStyle () ;
t1.showDim () ;
tl.showColor() ;
Console.WriteLine ("Plohad ravna " Q t1.area());
Console.WriteLine();
Console.WriteLine("Informatsiya o t2: ");
t2.showStyle() ;
t2.showDim();
t2.showColor();
Console.WriteLine("Plohad ravna " Q t2.area()); }
}
Dastur bajarilgandan so’ng quyidagi natijaga erishamiz.
Informatsiya o t1:
Treugolnik pryamougolno’y
Shirina i vo’sota ravno’ 8 i 12
Svet siniy
Plohad ravna 4 8
Informatsiya o t2:
Treugolnik ravnobedrenno’y
Shirina i vo’sota ravno’ 2 i 2
Svet krasno’y
Plohad ravna 2
Bunda ColorTriangle sinfi Triangle va TwoDShape xususiyatlaridan tuliq foydalangan xolda
o’zining color maydonini qo’shadi.
Konstruktorni chaqirish ketma-ketligi
Konstruktorlar bajarilishi ketma - ketligi avval baza konstruktorlaridan boshlanib keyin xosila
konstruktorlarga o’tiladi.
G’G’ Demonstratsiya poryadka vo’polneniya konstruktorov.
using System;
G’G’ Sozdaem bazovo’y klass.
class A {
public A() {
Console.WriteLine("Sozdanie klassa A.");
}
}
G’G’ Sozdaem klass, proizvodno’y ot A.
class V : A {
public VO {
Console.WriteLine("Sozdanie klassa V.");
}
}
G’G’ Sozdaem klass, proizvodno’y ot V.
class S : V {
public C( ) {
Console.WriteLine ("Sozdanie klassa S.");
}
}
class OrderOfConstruction {
public static void Main ( ) {
S s q new C ( );
}
}
Ushbu bajarilishlarning ketma-ketligi quyidagi vaziyat bilan tushuntiriladi. Baza sinfi
konstruktori xosila sinfi konstruktoriga bog’liq bo’lmagan xolda o’z vazifasini bajaraveradi,
ammo xosila sinfi konstruktori baza sinfi konstruktoriga murojat etish extimolligi bor.
Baza sinfiga izoxlar va xosila sinfi ob’ektlari.
S# qat’iy turlangan til bo’lib, bir sinf tiplari ikkinchi sinf ob’ektlariga izox bera olmaydi:
G’G’ Eta programma ne skompiliruetsya.
class X {
int a;
public X(int i) {a q i;)
}
class Y { int a ;
public Y(int i) { a q i;}
}
class IncompatibleRef {
public static void Main ( ) {
X x q new X(10);
X x2;
Y u q new Y(5);
x2 q x; G’G’ OK, obe peremenno’ye imeyut odinakovo’y tip.
x2 q u; G’G’ Oshibka, zdes peremenno’ye raznogo tipa.
}
}
Ammo S# tilida baza sinf ob’ekti shu bazadan kelib chiqqan xosila sinfi ob’ektlariga izox bera
oladi.
G’G’ Sso’lka na bazovo’y klass mojet ukazo’vat na
G’G’ ob’ekt proizvodnogo klassa.
using System;
class X {
public int a;
public X(int i) {
a q i;
}
}
class Y : X {
public int b;
public Y(int i, int j) : base(j) {
b q i;
}
}
class BaseRef {
public static void Main() {
X x q new X(10) ;
X x2;
Y u q new Y(5, 6) ;
x2 q x;
G’G’ OK, obe peremenno’ye imeyut odinakovo’y tip.
Console.WriteLine("x2.a: " Q x2.a);
x2 q u; G’G’ Vse ravno ok, poskolku klass Y
G’G’ vo’veden iz klassa X.
Console.WriteLine("x2.a: " Q x2.a);
G’G’ X-sso’lki "znayut" tolko o chlenax klassa X.
x2.a q 19; G’G’ OK
G’G’ x2.bq27; G’G’ Oshibka, v klasse X net chlena b.
}
}
Shu bilan birga bu yerda asosiy rolni izox berilayotgan o’zgaruvchan o’ynaydi va u qaysi
ob’ektdagi a’zolarga izox berish imkoniyati mavjudligini aniqlaydi.
G’G’ Peredacha sso’lki na proizvodno’y klass
G’G’ sso’lke na bazovo’y klass.
using System;
class TwoDShape {
double pri_width; G’G’ Zakro’to’y chlen.
double pri height; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public TwoDShape ( ) {
width q height q 0.0;
}
G’G’ Konstruktor klassa TwoDShape.
public TwoDShape (double w, double h) {
width q w;
height q h; }
G’G’ Sozdaem ob’ekt, v kotorom shirina ravna vo’sote.
public TwoDShape (double x) {
width q height - x;
}
G’G’ Sozdaem ob’ekt iz ob’ekta.
public TwoDShape (TwoDShape ob) {
width q ob.width;
height q ob.height;
}
G’G’ Svoystva width i height.
public double width
get { return pri_width; }
set { pri_width q value; } }
public double height {
get { return pri_height; }
set { pri_height q value; }
}
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
}
}
G’G’ Klass treugolnikov, proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public Triangle() {
style q "null";
}
G’G’ Konstruktor klassa Triangle.
public Triangle (string s,
double w,
double h) :
base(w, h) {
style q s;
}
G’G’ Sozdaem ravnobedrenno’y treugolnik.
public Triangle(double x) : base(x) {
style q "ravnobedrenno’y";
}
G’G’ Sozdaem ob’ekt iz ob’ekta.
public Triangle(Triangle ob) : base(ob) {
style q ob.style;
}
G’G’ Metod vozvrahaet plohad treugolnika,
public double area () {
return width * height G’ 2;
G’G’ Metod otobrajaet tip treugolnika.
public void showStyle () {
Console.WriteLine("Treugolnik " Q style);
}
}
class Shapes7 {
public static void Main() {
Triangle t1 q new Triangle("pryamougolno’y", 8.0, 12.0);
G’G’ Sozdaem kopiyu ob’ekta t1.
Triangle t2 q new Triangle (t1);
Console.WriteLine("Informatsiya o t1: ") ;
t1.showStyle() ;
t1.showDim();
Console.WriteLine ("Plohad ravna " Q t1.area ());
Console.WriteLine() ;
Console.WriteLine("Informatsiya o t2: ");
t2.showStyle() ;
t2.showDim () ;
Console.WriteLine("Plohad ravna " Q t2.area());
}
}
Virtual usullar va ularning qayta aniqlanishi
Virtual usul deb baza sinfida virtual so’zi bilan e’lon kilingan va shu bilan birga bitta yoki bir
nechta xosila sinflarda qaytadan anaqlangan usulga aytiladi.
Agarda usulni baza sinfda virtual deb e’lon qilish uchun virtual so’zidan foydalansa, uni xosila
sinfda qayta aniqlash uchun override so’zidan foydalanadi.
Usullarning dinamik nozimlash – bu qayta aniqlangan usulni dastur bajarilish vaqtida
chaqirilishi.
G’G’ Demonstratsiya virtualnogo metoda.
using System;
class Base {
G’G’ Sozdaem virtualno’y metod v bazovom klasse.
public virtual void who ( ) {
Console.WriteLine ("Metod who ( ) v klasse Base.");
}
}
class Derivedl : Base {
G’G’ Pereopredelyaem metod who ( ) v proizvodnom klasse.
public override void who ( ) {
Console.WriteLine("Metod who ( ) v klasse Derivedl");
}
}
class Derived2 : Base {
G’G’ Snova pereopredelyaem metod who ( )
G’G’ v drugom proizvodnom klasse.
public override void who ( ) {
Console.WriteLine("Metod who ( ) v klasse Derived2");
}
}
class OverrideDemo {
public static void Main ( ) {
Base baseOb q new Base ();
Derivedl dOb1 - new Derived1 ( );
Derived2 dOb2 q new Derived2 ( );
Base baseRef; G’G’ Sso’lka na bazovo’y klass.
baseRef q baseOb;
baseRef.who ( );
baseRef q dObl;
baseRef.who ( ) ;
baseRef q dOb2;
baseRef.who ( );
}
}
Dastur bajarilgandan so’ng quyidagi natijaga erishamiz.
Metod who ( ) v klasse Base.
Metod who ( ) v klasse Derived1
Metod who ( ) v klasse Derived2
Virtual usulni qaytadan aniqlash shart emas. Agar xosila sinf virtual usulda o’z talqinini
bermasa, baza sinfda aniqlangan talqindan foydalanadi.
G’* yesli virtualno’y metod ne pereopredelen
v proizvodnom klasse, ispolzuetsya metod
bazovogo klassa. *G’
using System;
class Base {
G’G’ Sozdaem virtualno’y metod v bazovom klasse.
public virtual void who(){
Console.WriteLine("Metod who() v klasse Base");
}
}
class Derivedl : Base {
G’G’ Pereopredelyaem metod who () v proizvodnom klasse.
public override void who () {
Console.WriteLine("Metod who() v klasse Derived1");
}
}
class Derived2 : Base {
G’G’ Etot klass ne pereopredelyaet metod who ( ).
}
class NoOverrideDemo {
public static void Main ( ) {
Base baseOb q new Base ( );
Derived1 dObl q new Derived1( );
Derived2 dOb2 q new Derived2 ( );
Base baseRef; G’G’ Sso’lka na bazovo’y klass.
baseRef q baseOb;
baseRef.who ( ) ;
baseRef q dObl;
baseRef.who ( ) ;
baseRef q dOb2;
baseRef.who ( ); G’G’ Vo’zo’vaet metod who ( ) klassa Base.
}
}
Dastur bajarilgandan so’ng quyidagi natijaga erishamiz.
Metod who ( ) v klasse Base
Metod who ( ) v klasse Derived1
Metod who ( ) v klasse Base
Agar yuqori darajali ierarxiyada xosila sinfi virtual usulda qaytadan aniqlanmasa, unda
ierarxiyada eng pastda joylashgan virtual usuldan foydalanadi.
G’* yesli proizvodno’y klass ne pereopredelyaet virtualno’y
metod v sluchae mnogourovnevoy ierarxii, budet vo’polnen
pervo’y pereopredelenno’y metod, kotoro’y obnarujitsya
pri prosmotre ierarxicheskoy lestnitso’ v napravlenii
snizu vverx. *G’
using System;
class Base {
G’G’ Sozdaem virtualno’y metod v bazovom klasse.
public virtual void who ( ) {
Console.WriteLine("Metod who ( ) v klasse Base");
}
}
class Derivedl : Base {
G’G’ Pereopredelyaem metod who () v proizvodnom klasse,
public override void who() {
Console.WriteLine("Metod who() v klasse Derived1");
}
class Derived2 : Derived1 {
G’G’ Etot klass ne pereopredelyaet metod who().
}
class Derived3 : Derived2 {
G’G’ Etot klass takje ne pereopredelyaet metod who().
}
class NoOverrideDemo2 {
public static void Main() {
Derived3 dOb q new Derived3();
Base baseRef; G’G’ Sso’lka na bazovo’y klass.
baseRef q dOb;
baseRef.who ( ); G’G’ Vo’zo’vaet metod who ( )
G’G’ iz klassa Derived1.
}
}
Dastur bajarilgandan so’ng quyidagi natijaga erishamiz.
Metod who ( ) v klasse Derived1
Bu yerda Derived1 sinfini qoldirgan Derived2 sinfi Derived3 sinfini qoldiradi, Derived1 esa o’z
navbatida Base sinfini qoldiradi. Bu programmani natijalari who() usuli Derived3 sinfida ham,
Derived2 sinfida ham qayta aniqlanmagan, lekin Derived1 sinfida qayta aniqlangan.
Virtual usullarning qo’llanishi.
Virtual usullar kuchini yanada yaxshiroq sezish uchun uni TwoDShape sinfiga qo’llaymiz.
Oldingi misollarda area () usulida aniqlanishi keltirilgan. Figiralar yuzasini hisoblashda
TwoDShape sinfida area() virtual usulidan foydalanish qulayroq ekanligi to’g’risida fikr
tug’iladi. Buni keyingi keltirilgan programmada ko’rish mumkin. qulaylik uchun TwoDShape
sinfiga name xususiyati kiritilgan.
G’G’ Ispolzovanie virtualno’x metodov i polimorfizma.
using System;
class TwoDShape {
double pri_width; G’G’ Zakro’to’y chlen.
double pri_height; G’G’ Zakro’to’y chlen.
string pri_name; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public TwoDShape() {
width q height q 0.0;
name q "null";
}
G’G’ Konstruktor s parametrami.
public TwoDShape(double w, double h, string n) {
width q w;
height q h;
name q n;
}
G’G’ Sozdaem ob’ekt, u kotorogo shirina ravna vo’sote.
public TwoDShape(double x, string n) {
width q height q x;
name q n;
}
G’G’ Sozdaem ob’ekt iz ob’ekta.
public TwoDShape(TwoDShape ob) {
width q ob.width;
height q ob.height;
name q ob.name;
}
G’G’ Svoystva width, height i name.
public double width {
get { return pri_width; }
set { pri_width q value; }
}
public double height {
get ( return pri_height; }
set { pri_height - value; }
}
public string name {
get { return pri_name; }
set { pri_name q value; ) }
public void showDim() {
Console.WriteLine("Shirina i vo’sota ravno’ " Q
width Q " i " Q height);
public virtual double area() {
Console.WriteLine(
"Metod area() neobxodimo pereopredelit.");
return 0.0;
}
}
G’G’ Klass treugolnikov, proizvodno’y ot klassa TwoDShape.
class Triangle : TwoDShape {
string style; G’G’ Zakro’to’y chlen.
G’G’ Konstruktor po umolchaniyu.
public Triangle() {
style - "null";
}
G’G’ Konstruktor s parametrami.
public Triangle(string s, double w, double h) :
base(w, h, "treugolnik") {
style q s;
}
G’G’ Sozdaem ravnobedrenno’y treugolnik.
public Triangle(double x) : base(x, "treugolnik") {
style q "ravnobedrenno’y";
}
G’G’ Sozdaem ob’ekt iz ob’ekta.
public Triangle(Triangle ob) : base(ob) {
style q ob.style;
}
G’G’ Pereopredelyaem metod area() dlya klassa Triangle,
public override double area() {
return width * height G’ 2;
}
G’G’ Metod otobrajaet tip treugolnika.
public void showStyle() {
Console.WriteLine("Treugolnik " Q style);
}
}
G’G’ Klass pryamougolnikov, proizvodno’y ot klassa TwoDShape.
class Rectangle : TwoDShape {
G’G’ Konstruktor s parametrami.
public Rectangle(double w, double h) :
base(w, h, "pryamougolnik"){ }
G’G’ Sozdaem kvadrat.
public Rectangle(double x) :
base(x, "pryamougolnik") { }
G’G’ Sozdaem ob’ekt iz ob’ekta.
public Rectangle(Rectangle ob) : base(ob) { }
G’G’ Metod vozvrahaet true, yesli pryamougolnik - kvadrat.
public bool isSquare() {
if(width qq height) return true;
return false;
}
G’G’ Pereopredelyaem metod area() dlya klassa Rectangle.
public override double area() {
return width * height;
}
class DynShapes {
public static void Main() {
TwoDShape[] shapes q new TwoDShape[5];
shapes[0] - new Triangle("pryamougolno’y", 8.0, 12.0);
shapes[1] q new Rectangle(10);
shapes[2] q new Rectangle(10, 4);
shapes[3] q new Triangle(7.0);
shapes[4] q new TwoDShape(10, 20,
"zagotovka dlya figuro’");
for(int iq0; i < shapes.Length; iQQ) {
Console.WriteLine("Ob’ektom yavlyaetsya " Q
shapes[i].name);
Console.WriteLine("Plohad ravna " Q
shapes [i].area () ) ;
Console.WriteLine();
}
}
}
Ushbu dasur bajarilgandan so’ng quyidagi natijani olamiz:
Ob’ektom yavlyaetsya treugolnik
Plohad ravna 48
Ob’ektom yavlyaetsya pryamougolnik
Plohad ravna 100
Ob’ektom yavlyaetsya pryamougolnik
Plohad ravna 40
Ob’ektom yavlyaetsya treugolnik
Plohad ravna 24.5
Ob’ektom yavlyaetsya zagotovka dlya figuro’
Metod area() neobxodimo pereopredelit.
Plohad ravna 0
Dasturni batafsil ko’rib chiqamiz. Birinchidan, area() usul virtual kalit so’zi qo’llanilgan
TwoDShape sinfida bildirilgan va Triangle va Rectangle sinflarida qayta aniqlangan. Har bir
qayta aniqlangan area() usul ob’ekt shakliga mos keluvchi yuzani hisoblaydi. Bu holda, agar
ellipslar berilgan bo’lsa, area() usuli bu sinfda ellips yuzasini hisoblaydi.
Merosxo’rlik
Merosxo’rlik – bu bir ob’ekt uning yordamida boshQasining xususiyatlarini o’ziga olishi
mumkin bo’lgan xossadir. Shuning uchun yuQoridan Quyiga yo’nalgan ierarxik tasniflash
konsepsiyasi Qo’llab-Quvvatlanadi. Masalan, aytish mumkinki, Mazali Qizil olma sinfi o’z
navbatida mahsulotlar sinfiga taalluQli mevalar sinfining bir Qismi bo’lgan olma sinfining
Qismlaridan biri hisoblanadi. YA’ni mahsulotlar sinfi uning sinfostisi hisoblangan mevalarga
ham Qo’llab bo’ladigan muayyan sifatlarga ega (esa bo’ladigan, to’yimli va shunga o’xshashlar).
Mevalar sinfining ushbu sifatlariga Qo’shimcha ravishda uni boshQa mahsulotlardan farQlab
turuvchi o’ziga xos (sersuvligi, shirinligi va hokazo) xususiyatlari mavjud. Olmalar sinfini
faQatgina olmalarga tegishli sifatlar (daraxtda o’sishi, tropik mevalar emasligi va hokazo)
belgilab beradi. Mazali Qizil olma sinfi o’z navbatida oldingi sinflarning barcha sifatlarini meros
Qilib oladi va faQatgina ularni noyob Qiladigan sifatlarni belgilab beradi.
Meros olishni amalga oshirmasdan har bir ob’ekt o’zining barcha xususiyatlarini aniQ belgilashi
kerak; meros olayotganda ob’ekt o’zining sinfi chegarasida uni noyob Qiladigan sifatlarni
aniQlab olishi lozim. U o’zining ota-onalar sinfidan umumiy atributlarni meros Qilib olishi
mumkin. Shunga ko’ra, aynan merosxo’rlik mexanizmi bir ob’ektga o’z sinfining spesifik
namunasi bo’lish imkonini beradi.
DaQiQali amaliyot
1.
OYD tamoyillarini ayting.
2.
Nima inkapsulyatsiyaning asosiy elementi hisoblanadi?
Savol. Sizningcha, OYD katta dasturlarni boshQarishning samarador usuli hisoblanadi, lekin u
nisbatan katta bo’lmagan dasturlarni ortiQcha murakkablashtirishi mumkin, degan fikr ham
mavjud. Modomiki siz, barcha S# dasturlar Qaysidir darajada ob’ektga-yo’naltirilgan bo’ladi,
deb ta’kidlayapsiz, bu holda katta bo’lmagan S# dasturlarni yozishda noQulaylik kelib
chiQmaydimi?
Javob. Yo’Q, keyinchalik siz guvohi bo’lasiz, S# da OYD dan foydalanilganda katta bo’lmagan
hajmdagi kodlar uchun amalda dasturlarning murakkabligiga ta’sir Qilmaydi. Garchi S# Qat’iy
ob’ektli modelga ega bo’lsada, siz uni Qo’llash bosQichini aniQlashda yetarlicha erkinlikka ega
bo’lasiz. Katta bo’lmagan dasturlar uchun “ob’ektga yo’naltirilganlik” sal-pal seziladi, dasturlar
hajmining o’sish choralariga ko’ra unga katta hajmdagi ob’ektga-yo’naltirilgan xossalarni
birlashtirish mumkin.
S# tilidagi kalit so’zlar
S# tilida 77 ta kalit so’zlar (1.1 jadval) aniQlangan bo’lib, ularni o’zgaruvchilarning, sinflarning
va usullarning nomlari sifatida ishlatish mumkin emas. Barcha kalit so’zlar faQat satrli , ya’ni
kichik harflar bilan yoziladi.
Jadval 1.1. S# ning kalit so’zlari
abstract
as
base
bool
breack
byte
case
catch
char
checked
class
const
continue
decimal
default
delegate
do
double
else
enum
event
explicit
extern
false
finally
fixed
float
for
foreach
goto
if
implicit
in
mt
interface
internal
is
lock
Long
namespace
new
null
object
operator
out
override
params
private
protected
publick
readonly
ref
return
sbyte
sealed
short
sizeof
stackalloc
static
string
struct
switch
this
throw
true
try
typeof
uint
ulong
unchecked
unsafe
ushort
using
vortual
volatile
void
while
Identifikatorlar
Identifikator- deb, bir yoki bir necha belgilar ketma-ketligidan iborat bo’lgan nomlashga aytiladi.
Odatda bularning birinchi belgilari ixtiyoriy harfdan yoki pastki chiziQcha belgisidan
boshlanishi mumkin. Keyingilari esa harf, pastki chiziQcha belgisi yoki raQam kabilardan iborat
bo’lishi mumkin. Pastki chiziQcha belgisi o’zgaruvchining nomini o’Qilishini yaxshilash uchun
ishlatiladi. Masalan, line__count, Test, x, V'2, MaxLoadup, _top, my_var, sample23.
C# kompilyatori yuQori va Quyi registr belgilarini har xil deb Qabul Qiladi. Masalan, lola va
Lola nomlari har xil nomlardir. BoshQa algoritmik tillardagi singari, identifikator raQamdan
boshlanishi mumkin emas. Ammo, zarur bo’lsa kalit so’zlarning oldiga @ belgisini Qo’yish
bilan ularni identifikatorga aylantirish mumkin. Masalan: @for, @Var. Ammo, izoh tarzida
shuni ham aytib o’tish kerakki, iloji boricha bunday belgilashlardan foydalanish tavsiya
etilmaydi.
Ma’lumki, identifikatorlar- S# da usullarning, o’zgaruvchilarning yoki foydalanuvchi tomonidan
aniQlangan elementlarning nomlarini ifodalash uchun ishlatiladi.
S# kutubxonasi
Bu bobda taQdim etilgan dasturlarda, o’rnatilgan ikkita WriteLine () va Write usullaridan
foydalanildi. Aytib o’tilganidek, bu usullar System fazosiga mansub bo’lgan Console sinfining
a’zolari bo’lib hisoblanadi. Qaysiki System fazosi ham o’z navbatida .NET Framework
kutubxonalar sinfida aniQlangan bo’ladi. .NET Framework kutubxonalar sinfi S# da
kiritishG’chiQarish amalini Qo’llashni amalga oshirish uchun, satrlarni Qayta ishlash uchun,
tarmoQda ishlash va GUI interfeyslarini yaratish uchun foydalaniladi. C# standart .NET
platformasi sinflari bilan chambarchas integrallashgan. Ko’ryapsizki, ixtiyoriy C#-dasturda
ishlatiladigan kutubxonalar sinfi ko’pchilik funksional imkoniyatlarni ta’minlaydi. S#da
dasturchi bo’lish uchun mana shu standart sinflarni o’rganish zarur. Bu kitobda V etoy knige
opisano’ razlichno’ye metodo’ i elemento’ biblioteki klassov .NET kutubxonalar sinfining har
xil usullari va elementlari tasvirlangan bo’lib, kutubxonaning ancha kattaligi tufayli uning bir
Qancha komponentalarini mustaQil o’rganishga to’g’ri keladi.
1. MSIL nima va u S# uchun nega bunchalik zarur?
2. Tilga bog’liQ bo’lmagan bajarish muhiti (CLR) nima?
3. OYDning uchta asosiy tamoyili nimalar?
4. S# da yozilgan dasturning bajarilishi Qaysi usuldan boshlanadi?
5. O’zgaruvchi nima? Nomlar fazosi deb nimaga aytiladi?
6. Quyidagi nomlarning Qaysi birlari S# da to’g’ri emas ?
a) j count
b) Scount I
v) count 27
g) 67count
d) @if
7.
Bitta satrli izoh Qanday tuziladi? Ko’p satrli izoh Qanday tuziladi?
8.
if operatorining sintaksisini yozing. for operatorining sintaksisini yozing .
9.
Kod bloki Qanday tuziladi? 10.Har bir S# dasturini using System; operatori bilan
boshlash shartmi ?
11.
Oy sirtidagi og’irlik kuchi yer sirtidagi og’irlik kuchining taxminan 17 foyizini tashkil
etadi Sizning Oydagi og’irligingizni Qanday bo’lishini hisoblaydigan dastur yozing.
12.
1-2 loyihalarni shunday o’zgartiringki, natijada dastur dyuymni metrga aylantirib
beradigan jadvalni chiQarsin. Natija 0 dan 100 dyuymgacha bo’lgan oraliQda olingan
masofalar to’plami uchun hisoblansin. Dastur har 12 satrdan so’ng bo’sh satrni bosib
chiQaradigan bo’lsin. (Bir metr
taxminan 39.37 dyuymga teng.)
Birinchi oddiy dastur
Tilning detallarini chuQur o’rganishdan oldin S# da yozilgan QisQa va oddiy dasturni
kompilyatsiya Qilamiz va ishga solamiz.
G’*
Bu S# da yozilgan oddiy dastur.
1.
Inkapsulyatsiya, polimorfizm va merosxo’rlik OYD tamoyillari bo’lib hisoblanadi.
2.
Sinf inkapsulyatsiyaning asosiy elementi hisoblanadi.
Dasturlar kodini o’z ichiga olgan fayl — Example.cs.
using System; class Example {
G’G’ S# dasturi Main() usulini chaQirish bilan boshlanadi. public static void MainO i
Console.WriteLine(“Oddiy S# - dastur.”);
S# - dasturni kompilyatsiya Qilish, ishga tushirish va tahrirlashning ikkita usuli mavjud.
Birinchidan, siz kompilyatsiyani buyruQlar satridan csc.exe dasturini ishga tushirish orQali
bajarishingiz mumkin. Ikkinchidan, Visual CQQ (Integrated Development Environment, IDE)
ishlanmasining birlashtirilgan muhitidan foydalanishingiz mumkin. Bu ikkala usullar Quyida
berilgan.
BuyruQlar satridan kompilyatsiya Qilish
BuyruQlar satridan kompilyatsiya Qilish o’zida garchi siz tijorat loyihalari uchun ehtimol Visual
CQQ ishlanmasining birlashtirilgan muhitidan foydalansangiz ham S# dasturlar kitobida
keltirilganlarning ko’pi bilan ishlashning nisbatan yengil usulini namoyon Qiladi.
S#-dasturini buyruQlar satridan kompilyatsiya Qilish va ishga tushirish uchun sizga uchta
harakatni amalga oshirish zarur bo’ladi.
1.
Dasturlar kodi mavjud bo’lgan fayllarni yaratish.
2.
Dasturni kompilyatsiya Qilish.
3.
Dasturni ishga tushirish.
Fayl yaratish
Mazkur kitobda berilgan dasturlarni Osborne kompaniyasining www.osborne.com Web-tuguni
yoki dasturlar kodini Qo’lga kiritish ixtiyori bilan yuklash mumkin.
Qo’lga kiritilganda dasturni matn redaktori (masalan, Notepad)dan foydalangan holda faylga
yuklang. Matnli ASCII-fayllari formatlashtirish elementlarisiz yaratilishi kerak, modomiki
bunday axborot kompilyatsiya Qilishda xatoga olib kelishi mumkin. Dasturni kiritganingizdan
keyin faylga Example. ss degan nom bering.
Dasturni kompilyatsiya Qilish
Dasturni kompilyatsiya Qilish uchun S# csc.exe kompilyatorini buyruQlar satridagi boshlang’ich
faylning nomini ko’rsatgan holda ishga tushirish zarur:
C:g’>csc Example.cs
Esc kompilyatori MSIL-versiya dasturi mavjud Example.exe faylini yaratadi. Garchi MSIL ijro
etiladigan kod bo’lmasa ham, unda (exe) ijro etiladigan fayl mavjud. Example.exe faylini ishga
tushirishga urinishda ijro muhiti (CLR) tiliga bog’liQ bo’lmagan holda JIT-kompilyator
avtomatik tarzda harakatga keladi. Agarda siz kompyuterda installyatsiya Qilinmagan .NET
Framework da Example.exe faylini (yoki MSIL mavjud boshQa ixtiyoriy faylni) bajarishga
harakat Qilsangiz, dastur CLR yo’Qligi sababli ishlamaydi.
Eslatma
Css.exe kompilyatorini ishga tushirish oldidan sizga odatda g’Program Filesg’Mic-rosoft Visual
Studio.NETg’Vc7g’Bin katalogida joylashgan vcvars32.bat buyruQ faylini ishga tushirish kerak
bo’lishi mumkin. Alternativ sifatida masalalar panelidagi Pusk|Dasturlar menyusida joylashgan
Microsoft Visual Studio.NET 7.0 menyuostiga o’tkazilgan instrumentlar ro’yxatidagi Visual
Studio.NET Command Prompt elementini tanlash orQali buyruQlar satridan kompilyatsiya
jarayonlarini harakatga keltirish mumkin.
Dasturlarni ishga tushirish
Dasturlarni ishga tushirish uchun uning nomini Quyidagi ko’rsatilganidek buyruQlar satriga
kiriting:
S:g’>Example
Qachonki dastur ishga tushsa, ekranda Quyidagi satr paydo bo’ladi:
Oddiy S#-dastur.
Visual CQQ IDE dan foydalanish
Visual Studio 7 versiyasidan boshlab Visual CQQIDE S#-dasturlarini kompilyatsiya Qilishi
mumkin. Visual CQQ IDE dan foydalanib S#-dasturini tahrirlash, kompilyatsiya Qilish va ishga
tushirish uchun siz Quyida sanab o’tilgan harakatlarni amalga oshirishingiz zarur bo’ladi.
(Esli na vashem kompyutere installirovana drugaya versiya, vozmojno, poryadok deystviy budet
drugim.)
(Agarda sizning kompyuteringizda Visual CQQ ning boshQa versiyasi installyatsiya Qilingan
bo’lsa, harakatlar tartibi boshQacha bo’lishi mumkin.)
1. File|New| Project menyu punktlarini tanlash orQali yangi bo’sh S#-loyiha yarating. Keyin 1rasmda ko’rsatilganidek Visual C# Project papkasini, undan so’ng Empty Project
piktogrammasini tanlang.
:!
• -1 Visual Basic Projects
■M Visual CQQ Projects Cj Setup and Deployment Pro)ect5 Sh- £3 Other Projects
Cj Visual Studio Solutions
ASP.NET Web ASP.NET Web Web Control
Application Service Library
I C:g’Documents and Settingsg’Pada!kag’Mon dokumento’g’g’ jwj '
for ::y;71{ ^.^g...'"!
V Samples
Visual Studio Sarrrotes
2. Loyiha yaratilganidan keyin sichQonchaning o’ng tugmachasini Solution darchasidagi loyiha
nomi ustida bosing. ChiQQan kontekst menyusidan Add punktini, keyin Add New Item punktini
tanlang. Sizning monitoringiz ekranida Quyidagi manzara paydo bo’ladi.
V* ProiectZ - Microsoft *)«S1 S* .NET [design] - Start Pag.
Hie £}№ SSew Project V* 0*1*3 Irate
3. Add New Item dialog oynasi ochilsa, Local Project Items punktini, undan keyin S# Code File
piktogrammasini tanlang. Sizning monitoringiz ekranidagi ko’rinish Quyidagicha bo’ladi.
[Add New Item - Projectl
4.
Dasturni yuklang va faylni Example.csc nomi ostida saQlang (Mazkur kitobda berilgan
dasturlarni Web-tugun www.osborne.com bilan yuklash mumkinligini eslang). Sizning
monitoringiz ekranida Quyida ko’rinish paydo bo’ladi.
5. Build menyusidagi Build punktini tanlash orQali dasturni kompilyatsiya Qiling.
6. Debug menyusidagi Start Without Debugging punktini tanlash orQali dasturni ishga
tushiring. Qachon dastur ishga tushsa rasmda ko’rsatilgan darcha paydo bo’ladi.
Dasturlardagi katta bo’lmagan o’zgarishlar.
Ushbu kitobda berilgan dasturlarni kompilyatsiya Qilish va ishga tushirish uchun har doim ham
yangi loyiha yaratish shart emas, o’sha S#-loyihadan foydalanish mumkin. Buning uchun
shunchaki ishlab turgan faylni o’chiring va yangisini Qo’shing, keyin uni kompilyatsiya Qiling
va ishga tushiring.
YUQorida ta’kidlanganidek, kitobning birinchi Qismida berilgan QisQa dasturlarni buyruQlar
satridan kompilyatsiya Qilish osonroQdir.
Garchi ushbu kitobdagi barcha dasturlar using System operatoridan foydalansa ham, lekin aslida
birinchi dasturni boshlanishida unga texnik ehtiyoj yo’Q. S# da har doim sinf (yoki usul) tegishli
bo’lgan makon nomini ko’rsatish orQali sinf (yoki usul) nomini to’liQ aniQlash mumkin.
Masalan, satr Quyidagicha yozilgan bo’lishi mumkin:
Console.WriteLine ("Oddiy S#-dastur.");
Shunga ko’ra, 1-misolni Quyidagicha yozish mumkin:
G’G’ Dasturning bu versiyasida operator ishlatilmaydi
G’G’ using System;.
class Example (
G’G’ S# dasturi MainO public static void Main() metodining bajarilishidan boshlanadi
Console.WriteLme () metodining to’liQ ta’rifi
G’G’ Bu yerda Console.WriteLine() metodi to’liQ aniQlangan .
System.Console.WriteLine ("Oddiy S#-dastur ") ;
Garchi System identifikatorini har gal ko’rsatish Qiyin bo’lsada, Qachonki shu sohaning a’zosi
ishlatilganda ko’pchilik S# dasturchilari o’zlarining barcha dasturlarini using System;
operatoridan boshlaydilar. Ammo, zarur bo’lganda sinf nomini yoki sinf a’zosini oshkor
aniQlashingiz mumkin. Buning uchun mazkur sinf Qaysi sohaga tegishliligi ko’rsatiladi.
3. S# tilidagi aniQlangan tiplar.
Qiymati bo’yicha aniQlangan tiplar.
Butun tiplar.
Suzuvchi nuQtali formatli sonlar.
O’nli formatdagi son.
Boolean, satriy tip.
Uzatma bo’yicha aniQlangan tiplar.
Ikkinchi oddiy dastur
Balkim, o’zlashtirish operatori dasturlashdagi asosiy operatorlardan biri bo’lib hisoblanadi.
O’zgaruvchi –bu xotiraning nomlangan Qismi bo’lib, unga Qiymat o’zlashtiriladi. Bu Qiymat
dastur bajarilishi davomida o’zgarishi mumkin. YA’ni o’zgaruvchining Qiymati fiksirlanmagan,
o’zgarishi mumkin.
Navbatdagi dasturda ikkita x va u o’zgaruvchilari hosil Qilinadi:
G’G’ Bu dastur o’zgaruvchilarni ishlatishni namoyish Qiladi
using System;
class Example2 {
public static void Main() (O’zgaruvchilarni e’lon Qilish
int x; G’G’ Bu satrda o’zgaruvchi e’lon Qilinadi.
int u; G’G’ Bu satrda yana bitta o’zgaruvchi e’lon Qilinadi
x q 100; G’G’ Bu satrda x o’zgaruvchiga G’G’ 100 Qiymat o’zlashti riladi .
Console.WriteLine("Peremennaya x soderjit znachenie " Q x); U q x G’ 2;
Console.WriteLine("Znachenie peremennoy u vo’chislyaetsya"); Console.Write("s pomohyu
vo’rajeniya xG’2 i ravno "); Console.WriteLine(u);
Dasturni bajarib, siz monitor ekranida Quyidagi xabarni ko’rasiz :
O’zgaruvchi x 100 Qiymatga ega.
O’zgaruvchi u ning Qiymati xG’2 ifoda yordamida hisoblanadi va 50 ga teng
Bu dasturda S# tilining yangi elementlari taQdim etilgan. Ushbu
int x; G’G’ Bu satrda x o’zgaruvchi e’lon Qilinadi.
operatori x nomli butun tipli o’zgaruvchini e’lon Qiladi. S# da barcha o’zgaruvchilar
ishlatilmasdan oldin e’lon Qilinishi shart. O’zgaruvchi Qabul Qilishi mumkin bo’lgan Qiymatlar
tipi, aniQlangan bo’lishi shart. Bu o’zgaruvchi tipi ko’rsatiladi, deb Qabul Qilingan. YUQorida
keltirilgan dasturda x o’zgaruvchi butun tipli Qiymatlarni Qabul Qiladi. S#da butun tipli
o’zgaruvchilarni e’lon Qilish uchun o’zgaruvchi oldiga int kalit so’zini joylashtirish kerak
bo’ladi.
Navbatdagi satrda ikkinchi u o’zgaruvchi e’lon Qilinadi:
int u; G’G’ Bu satrda yana bitta o’zgaruvchi u e’lon Qilinadi.
Bu yerda x uchun Qo’llanilgan e’lon Qilish ko’rinishi foydalaniladi, ammo o’zgaruvchi nomi
boshQa.
Ko’pgina hollarda o’zgaruvchini e’lon Qilish uchun Quyidagi sintaksisli operator ishlatiladi:
type var-name;
Bu yerda type so’zi e’lon Qilinadigan o’zgaruvchi tipini ko’rsatadi, var-name — esa o’zgaruvchi
nomi. S# da int tipidan boshQa bir necha tiplar ham Qo’llaniladi.
Quyidagi satrda o’zgaruvchiga 100 Qiymati o’zlashtiriladi:
x q 100; G’G’ Bu satrda o’zgaruvchiga 100 Qiymati o’zlashtiriladi.
S# da o’zlashtirish operatori tenglik belgisi bilan ifodalanadi. U tenglik belgisining o’ng
tomonidagi Qiymatni chap tomonidagi o’zgaruvchi nomiga o’zlashtiriladi.
Navbatdagi satr x o’zgaruvchining Qiymatini "O’zgaruvchi x ushbu Qiymatga ega ", degan
yozuvdan so’ng bosib chiQaradi .
Console.WriteLine("O’zgaruvchi x ushbu Qiymatga ega" Q x);
Bu satrning bajarilishidagi Q belgisi "O’zgaruvchi x ushbu Qiymatga ega" satridan so’ng
chiQishini ta’minlaydi. Demak, bitta WriteLine () operatorida Q yordamida bir necha
elementlarni bog’lash mumkin ekan. Navbatdagi satrda u o’zgaruvchi x yordamida hisoblanadi:
u q xG’2;
YA’ni, x o’zgaruvchining Qiymati 2 ga bo’linadi va u o’zgaruvchiga joylashtiriladi. Natijada u
ning Qiymati 50 ga teng bo’ladi. X o’zgaruvchining Qiymati esa o’zgarmasdan Qoladi.
BoshQa dasturlash tillar singari S# ham barcha arifmetik amallarni Qo’llaydi:
Q Qo’shish, - Ayirish, * Ko’paytirish, G’ Bo’lish
Dastur kodining Quyidagi uchta satrini ko’ramiz:
Console.WriteLine("u o’zgaruvchining Qiymati ");
Console.Write(" xG’2 ifoda yordamida hisoblanadi va teng "); Console.WriteLine(u);
Bu yerda tilning yangi elementi va o’zgaruvchidan foydalanishning yangi varianti uchratiladi.
YAngi element –bu o’rnatilgan write () metodi bo’lib, ekranga " xG’2 ifoda yordamida
hisoblanadi va teng " degan satrni chiQarish uchun foydalaniladi. Bu satrdan keyin yangi satr
Qo’yilmaydi. Bu degani navbatdagi chiQarish amali kelsa, u shu satr oxiriga chiQariladi. Write
() metodi WriteLine () metodiga o’xshaydi, ammo u har bir chaQirilganda yangi satrdan
chiQarmaydi.
O’zgaruvchini Qo’llashning yangi varianti bu- u o’zgaruvchining WriteLine () metodini
chaQirishdagi mustaQil ishlatilishidir. S# da ixtiyoriy o’rnatilgan tiplardagi Qiymatlarni
chiQarish uchun Write () metodi Qanday ishlatilgan bo’lsa, WriteLine () metodi ham shunday
ishlatiladi.
Endi o’zgaruvchilarni e’lon Qilishning yana bitta imkoniyatini ko’ramiz. S#da bitta e’lon Qilish
operatori yordamida ikki va undan ortiQ o’zgaruvchilarni e’lon Qilish mumkin. Buning uchun
faQatgina o’zgaruvchilar bir-biridan vergul bilan ajratib Qo’yish yetarli. Masalan, x va u
o’zgaruvchilarni mana bunday e’lon Qilish mumkin:
int x, u; G’G’ Har ikkala o’zgaruvchini e’lon Qilish uchun
G’G’ bitta operator ishlatiladi .
Berilganlarning boshQa tiplari
Oldingi dasturda faQat butunsonli Qiymatlarni saQlaydigan int tipidagi o’zgaruvchi ishlatilgan
edi, Qaysiki bunda kasr Qiymatli sonlarni saQlash mumkin emas . OldinroQ aytib o’tilgan ediki,
C# int tipidan tashQari bir Qancha boshQa tiplarni ham Qo’llaydi. Kasr Qismli sonlar uchun
S#da ikkita, float va double tiplari aniQlangan bo’lib, mos ravishda oddiy va ikkilangan
aniQlikdagi sonlar ifodalash uchun ishlatiladi. Ko’proQ double tipi ishlatiladi. double tipidagi
o’zgaruvchilarni e’lon Qilish uchun sintaksisi Quyidagicha bo’lgan operator ishlatiladi:
double result;
Bu yerda result so’zi — o’zgaruvchi nomi bo’lib, double tipli, Qo’zg’aluvchan nuQtali sonlar
bilan ishlash imkonini beradi (masalan, u 122.23, 0.034, yoki -19.0 kabi sonlarni saQlashi
mumkin).
Mazkur int va double tiplari orasidagi farQni yanada yaxshiroQ tushunish uchun Quyidagi
dasturni bajaring:
G’*
Bu dasturda int va double tiplari orasidagi farQ namoyish Qilinadi
*G’using System; class Example3; public static void Main() ;
int ivar; G’G’ Kodning bu satrida ivar o’zgaruvchisi int tipida e’lon Qilinyapti.
double dvar; G’G’ Kodning bu satrida dvar o’zgaruvchisi double tipida e’lon Qilinyapti ivar q
100; G’G’ ivar o’zgaruvchisiga 100 Qiymati o’zlashtirilyapti.
dvarq100.0; G’G’dvar o’zgaruvchisiga 100.0 Qiymati o’zlashtirilyapti. Console.WriteLine("ivar
o’zgaruvchisining boshlang’ich Qiymati: " Q ivar); Console.WriteLine("dvar o’zgaruvchisining
boshlang’ich Qiymati: " Q dvar); Console. WriteLine () ; G’G’ Bo’sh satrni chiQaradi . < [Bo’sh
satrni chiQarish G’G’ Har ikkala o’zgaruvchining Qiymati 3 ga bo’linadi. ivar q ivar G’ 3; dvar
q dvar G’ 3.0;
Console.WriteLine("ivar o’zgaruvchisining bo’lishdan so’ngi Qiymati : " Q ivar);
Console.WriteLine("dvar o’zgaruvchisining bo’lishdan so’ngi Qiymati: " Q dvar); Quyida shu
dastur ishi natijasi keltiriladi:
ivar o’zgaruvchisining boshlang’ich Qiymati: 100
dvar o’zgaruvchisining boshlang’ich Qiymati: 100.0
ivar o’zgaruvchisining bo’lishdan so’ngi Qiymati : 33
dvar o’zgaruvchisining bo’lishdan so’ngi Qiymati: 33.3333333333333
Ko’ryapsizki, ivar o’zgaruvchisini 3ga bo’lishdan so’ngi Qiymati natijasi butun 33 soni bo’ladi,
ya’ni kasr Qismi yo’Qotildi. Lekin dvar o’zgaruvchisini 3ga bo’lishdan so’ngi Qiymatidagi kasr
Qismi saQlanadi. Dasturda ko’rsatilganidek, o’zgaruvchilarning Qiymatini Qo’zg’aluvchi
nuQtali ko’rinishda kiritishga zaruriyat bo’lsa, u e’lon Qilingan bo’lishi kerak ekan. Aks holda,
Qiymatlar butun tipli deb tushuniladi.Masalan, S# da 100 butun deb, 100.0 esa Qo’zg’aluvchi
nuQtali Qiymat deb hisoblanadi.
Shuning bilan birga, ekranga bo’sh satrni chiQarish uchun argumentsiz WriteLine () usulidan
foydalaniladi.
Professional javoblari
Savol. Nimaga S#da butun sonli va Qo’zg’aluvchi nuQtali Qiymatlar uchun turli tiplar mavjud?
Javob. S# dasturning samaradorligi uchun turli tipdagi berilganlarni Qo’llaydi. Masalan, butun
sonli Qiymatlar ustida bajariladigan amallar, Qo’zg’aluvchi nuQtali sonlar ustida bajariladigan
amallarga Qaraganda tezroQ bajariladi. Shu sababli, agar sizga sonlarning kasr Qiymatlari kerak
bo’lmasa, unda ortiQcha aniQliklar bilan hisoblashlarga, ya’ni float va double tipidagi
berilganlarga zaruriyat bo’lmaydi. Bundan tashQari, xotira o’lchami ba’zi bir tipdagi
berilganlarni saQlash uchun boshQa bir tipdagilarga Qaraganda kamroQ bo’lishi mumkin.
Berilganlarning har xil tiplarini hisobga olgan holda, S# sistemali resurslardan samarali
foydalanishga imkon beradi. Ba’zi bir algoritmlarning berilganlarning maxsus tiplarini talab
Qilishlarini ham inobatga olishni unutmang (hech bo’lmaganda shunda ancha samarali ishlaydi).
Loyiha 1-1. Temperatura Qiymatini almashtirish FtoC.cs
Garchi oldingi dasturning misollari S# tilining ba’zi bir zarur xossalarini namoyish Qilsada,
amalda bunday dasturlar unchalik foydali emas. Bu bosQichda S# tili bo’yicha sizning
bilimlaringiz kam bo’lsada, shunga Qaramasdan siz uni amalga Qo’llay olasiz. Bu loyihada biz
Farengeyt shkalasi bo’yicha berilgan temperatura Qiymatini Selsiy shkalasiga almashtirib
beradigan dastur tuzamiz. Dasturda double tipidagi ikkita o’zgaruvchi e’lon Qilinadi. Ulardan
birida Farengeyt shkalasi bo’yicha berilgan temperatura Qiymati, ikkinchisida esa
almashtirishdan hosil bo’lgan Selsiy shkalasidagi temperatura Qiymati saQlanadi. Mumkin siz
bilasiz, bunday almashtirishni bajarish uchun Quyidagi formula zarur:
S q 5G’9 * (F - 32)
bu yerda S — Selsiy shkalasidagi temperatura Qiymati (gradusda), F — Farengeyt shkalasi
bo’yicha berilgan temperatura Qiymati (gradusda).
Qadamba-Qadam instruksiya
1.
FtoC.cs nomli yangi S#-fayl tuzing. (Agar dastur kompilyatsiyasi buyruQ satridan
amalga oshirilmasdan, Visual CQQ IDE yordamida bajarilsa, u holda bu faylni oldin
tasvirlanganidek S# loyihaga Qo’shib Qo’yish kerak.
2.
Quyidagi dasturni faylga kiriting:
G’* Loyiha 1-1
Bu dastur Farengeyt shkalasi bo’yicha berilgan temperatura Qiymatini Selsiy shkalasiga
almashtirib beradi.
FtoC.cs nomli faylni ayting *G’
using System;
class FtoC {
public static void MainO {
double f; G’G’ Farengeyt shkalasi bo’yicha berilgan temperatura Qiymatini saQlaydi double s;
G’G’ Selsiy shkalasi bo’yicha berilgan temperatura Qiymatini saQlaydi
f q- 59.0; G’G’ f o’zgaruvchi -59 Qiymatini oladi
G’G’ (Farengeyt bo’yicha gradusda).
G’G’ So’ngra mavjud Qiymatlarni
G’G’ Selsiy shkalasiga almashtirish bajariladi
s q 5.0 G’ 9.0 * (f - 32.0);
Console.Write(f Q " gradus Farengeyt shkalasi bo’yicha teng ");
Console.WriteLine(s Q " gradus Selsiy shkalasi bo’yicha");
3. Visual CQQ IDE dan foydalanib (oldingi ko’rsatmalar asosida) dasturni kompilyatsiya Qiling,
yoki buyruQlar satriga Quyidagi buyruQni kiriting:
C>csc FtoC.cs
4. Visual CQQ IDE dagi dasturni ishga tushiring, yoki buning uchun buyruQlar satridan, taklif
etilgandan so’ng, bosh sinf nomini (mam usuli bo’lgan) kiriting:
OFtoC
Dasturning bajarilishi natijasida Quyidagi satr chiQadi:
Farengeyt shkalasi bo’yicha 59 gradus Selsiy shkalasidagi 15 gradusga.
5. Dastur Farengeyt shkalasidagi temperaturaning bitta Qiymatini (gradusdagi) Selsiy
shkalasidagi temperatura Qiymatiga almashtiradi. f o’zgaruvchidagi sonni o’zgartirish bilan siz
ixtiyoriy temperatura Qiymatini almashtirishingiz mumkin.
Bir daQiQalik amaliyot
I. S# da Qaysi kalit so’z butunsonli berilganlar tipi uchun ishlatiladi ?
. Chto oboznachaet termin double jumlasi nimani ifodalaydi?
3. S# dasturida using System; operatorini ishlatish majburiymi?
Ikkita boshQaruvchi operator
Metod ichkarisida operatorlarning bajarilishi yuQoridan Quyiga( ya’ni kod blokida yozilish
tartibida) yo’nalishida amalga oshiriladi. Ammo bunday bajarilish tartibini S# Qo’llaydigan har
xil boshQaruvchi operatorlar yordamida o’zgartirish mumkin. Garchi boshQaruvchi operatorlar
kitobda keyinroQ ko’rilsada, biz bu bo’limda ulardan ikkitasi to’g’risida to’xtalib o’tamiz.
Chunki ular keyinchalik dasturlarda ishlatiladi.
4. Tiplarni o’zgartirish.
Arifmetik tiplarni almashtirish.
Satrli tipga almashtirish.
Convert klassi va uning metodlari.
Almashtirishlarni tekshirish.
5. O’zgaruvchilar va ifodalar.
Identifikatorlar.
O’zgaruvchilarni e’lon Qilish.
Qiymat berish.
Lokal va global o’zgaruvchilar.
O’zgarmaslar.
Ifodalardagi amallar.
Ifodalarning Qurilishi.
Bitli amallar.
Surish amallari.
6. C# tili operatorlari
Qiymat berish operatori.
Tuzilma operator.
Bo’sh operator.
If-operatori.
REJASI
1.
Operatorlar.
2.
VA, YOki kiskartuvchi YOki va YUK razryadli operatorlari.
3.
Siljitish operatorlari.
4.
Operatorlarning prioriteti.
5.
Bir necha siklni boshkaruv uzgaruvchilarini foydalanish.
6.
Siklni aniklashda elementlarning yuk bulishi.
7.
Cheksiz sikl.
Uzlashtirish operatori.
Uzlashtirish operatori (q) ordinar belgisi Bilan belgilanadi. Uning axamiyati boshka tillardagidek
S# tilida xam shunaka. Uzlashtirish operatorining umuma yozilishi uyidagi turga ega.
Uzgaruvchiqifoda.
Bu yerda uzgaruvchi element tipi bilan bulish kerak. Uzlashtirish operatorining kiziki shundaki
ketma-ket uzlashtirsa buladi. Masalan, kodlashning keyingi kodi
Int x, y, z G’G’ Xqyqzq10; G’G’ x, y va z uzgaruvchilariga 100 ma’nosini tenglaymiz.
Bu fragmentda x, y, z uzgaruvchilari bitta instruksiyaning uzida 100 ga teng deb olinadi.
Uzlashtirish operatori ung tarafdagi ifodaning ma’nosini ketma ket berganligi sababli bu
instruksiya ishlaydi. Bu esa z-100 ifodaning ma’nosi 100 soniga tengligini bildirib, u keyinchalik
u uzgaruvchisiga uzlashtiriladi, undan keyin k uzgaruvchisiga uzlashtiriladi. Uzlashtiruv ketma
ketligining kullanilishi - bita ma’noga teng uzgaruvchilarning gruxini belgilashning oddiy iyuli
bulib topiladi.
Uzlashtirishning murakkab operatorlari.
S# da maxsus murakkab uzlashtirish operatorlari kurilib, ular uzlashtirishning belgili bir
kursatmalarining dasturlanishin soddalashtiradi. Avvalo misoldan boshlagan makul. Keyingi
kursatmani karab utaylik: IxqxQ10;
Murakkab uzlashtiruv operatorini ko’llanibbu misolni ko’yidagicha yozish mumkin: xQq10;
Qq jo’ftlik operatori kompilyatorga bo’yrik berib x uzgaruvchisiga x uzgaruvchisining berilgan
ma’nosi ikindisini va 10 sonini uzlashtiradi. YAna bir misol. |xqx-100; kursatmasi |x-q100 ga
tugri keladi.
Bu ikkala kursatma xam x uzgaruvchisiga uning avvalgi ma’nosini uzlashtiradi, 100 ga
kamaytirib.
4 – bob. Operatorlar.
Uzlashtirish operatorining murakkab versiyasi barcha binar operatorlari uchun mavjud buladi
(yani barcha ikkita operandlar Bilan ishlaydigan operatorlari uchun). Ularning umumiy kurinishi
kuyidagicha
Uzgaruvchi or q ifoda;
Bu yerda or elementi konkret arifmetik yoki logik operatori, j uzlashtirish operatori Bilan
biriktiriladi. Biriktirish operatorining kuyidagi variantlari mavjud bulishi
Qq -q *- G’q
%- &q 1q
uzlashtirishning murakkab operatorlari uning murakkab emas 1 operatoridan kichik bulib unda
murakkab versiyasini kupincha kiskartirilgan uzlashtirish operatori deb aytiladi.
Uzlashtirishning murakkab operatori ikkita xususiyatga ega. birinchidan, ular ixcham uzlarining
“uzun” ekvivalentlaridan. Ikkinchidan ularning mavjudligi effektivli kodlashni tashkil etishga
olib keladi (sababi bu yerda operant bir marotaba xisoblanadi). Shuning uchun xam professional
yozilgan dasturlarda siz ko’pincha murakkab uzlashtirish operatorini uchratasiz.
Razryadma razryad operatorlari
S # tilida razryadma razryad operatorlari terma bo’lib karaladi va ular S# tilini dasto’rlashda
soxalarini kengaytiradi. Razryadma razryad operatorlari uzlariring operadlariga tasir ko’rsatadi.
Ular fakat butunsonli operandlar uchun anikangan va bool float va double operandlari uchun
foydalanilmaydi.
Razryadma razryad operatorlari testlash uchun muljanlangan bit(razryadlarini) kuyish yoki
siljitish uchun va ulardan butunsonli ma’nolar tashkil etiladi. Razryadma razryad operatorlari
ko’pincha dasto’rlashning keng masalalarida sistemli toyfasida foydalaniladi, masalan,
uskunalarning xolatlarining axborotni surashtirishda foydalaniladi. Razryadma razryad
operatorlari 4 jadvalda keltirilgan.
Razryadma razryad operatorlari. Jadval 4.
Operator
Ma’nolari
&
1
l
»
«
Razryadli Va
Razryadli YOki
Razryadli kiskartiruvchi YOki
O’nga siljitish
Chapka siljitish
1 ga tuliQtirish ( yuk unar operatori)
VA, YOKI kiskarto’vchi YOKI va YUK razryadli operatorlari.
Razryadli VA, YOKI kiskarto’vchi YOKI va YUk operatorlari &, |, A va , simvollari bilan
beriladi. Ular logik operatorlari kanaka amalni bajarsa ular kam xuddi sho’ amalni bajaradi.
Ayirmachili sho’ndaki razryadli amallar bit asosida ishlaydi.Keyingi jadvalda razryadli
amallarning barcha ( 0 va 1) bo’lgan natiyjalari keltirilgan.
P ya p & z p I q p”
000001
100110
010111
111100
Va razryadli operatorini bitli axborotini maydalab kursatishga buladi.
Bo’ deganimiz 0 hoxlagan operandida 0-ni tashkil etadi mos kelo’vchi bit natiyjasida. Masalan
11010011
10101010
& ________
1000 0010
Keyingi dasto’rda razryadli operatorining jo’ft emas sonlardan jo’ft sonlarni olinishi ko’rsatiladi.
Bo’ amalga oshiriladi( nulni ) kichik razryadli sonida.
Masalan, 9 soni ikkilik kodida 0000 1001 soni bilan keltiriladi. Kichik razryadini nulga
keltirishda 8 sonini olamiz (0000 1000 ikkilik kodida)
G’G’ Va operatorini xoxlagan sonni G’G’
jo’ft soniga «aylantirish» da foydalanilishi
using System ;
class Make Even { public static void Main( ) { ushort num; ushort i;
for i q 1;
num qi;
Console. WriteLine (“ num: “Qnum) ;
num – (ushort ) ( num & Ox FFFE) ; G’G’ num & 1111 1110
Console.WriteLine ( “ num kichkina bitni olib tashlangannan kegin :”
Q nura Q “g’ n”) ;
}
}
}
Bo’ dasto’rning natiyjasi kuyidagi kurinishda bo’ladi:
num 1
num kichkina bitni olib tashlangandan so’ng : 0
num 2
num kichkina bitni olib tashlangandan so’ng : 2
num 3
num kichkina bitni olib tashlangandan so’ng : 2
num 4
num kichkina bitni olib tashlangandan so’ng : 4
num 5
num kichkina bitni olib tashlangandan so’ng : 4
num 6
num kichkina bitni olib tashlangandan so’ng : 6
num 7
num kichkina bitni olib tashlangandan so’ng : 6
num 8
num kichkina bitni olib tashlangandan so’ng : 8
num 9
num kichkina bitni olib tashlangandan so’ng : 8
num 10
num kichkina bitni olib tashlangandan so’ng : 10
Bo’ dasto’rda foydalaniladigan OxFFFE ning ma’nosi ikkilik kodida
1111 1111 1111 1110 turida keltiriladi. Shunday kilib, num & OxFFFE amali barcha bitlarni
o’zgartirilmagan xolatda koldiradi, kichkinasidan tashkari va unga nul ma’nosi kuyiladi. Shuning
uchun xam xoxlagan jo’ft son sho’ « tozalatmadan» utib jo’ft bulib xoladi, a xoxlagan jo’ft emas
soni esa undan jo’ft bo’lib chikadi.
Va operatori razryad ma’nosi aniklashda xam foydalaniladi Masalan, keyingi dasturda berilgan
son jo’ft emasligini aniklaydi.
G’G’ VA razryadli operatorining sonni jo’ft
G’G’ emasligini aniklashda foydalanilishi
using System;
class Isodd {
public static void Main 0 {
usort num;
num q10 ;
iff ( num & 1 ) num1 )
Console. WriteLine ( « Bo’ tekst kursatilmaydi».) ;
Num q11;
If (( num & 1) -1)
Console.WriteLine ( num Q “ – butun emas son »);
Bo’ dasto’rning natiyjasi kuyidagicha
11 – tok son.
Ikki xolatda xam if da VA amali bajariladi num o’zgaro’vchisi uchun 1 kuyiladi.
Agarda kichik bit num uzgaruvchisiga kuyilgan bulsa ( ya’ni 1 ga teng) num & 1 amalining
natiyjasi xam 1 ga teng buladi. Aksi xolda natiyja 0 ga teng bo’ladi. If instruksiya natiyjasi
bajariladi fakatkina analizlanayotgan son tok soni bo’lsa.
Razryadli testlash imkoniyatlarini, & operatorini dasturlar yaratishda byte tipini ikkilik formatda
kursatadi. Shu masalaning yechilgan bir variantini karaymiz.
G’G’ baytni tashkil etadigan bit ma’nolarini karaymiz.
using System;
class ShowBits { public static
void Main { int t;
byte val;
val q 123;
fort( t q 128; t > 0; t -tG’2) (
if {( val & t ) 1q0) Console.Write C “1”);
if (( val & t ) qq 0) Console.Write C ”0”);
Bo’ dasturning natiyjasi kuyidagicha buladi;
1111011
For siklida VA razryad operatori yordamida val o’zgaro’vchisining xar bir ma’nosi testdan utadi.
Agarda bo’ bitga mavjo’d bo’lsa unda 1 soni chikadi, aksi x olda 0 – soni chikadi
YOKI razryad operatori, VA operatoriga teskarisi bitga 1-ni kuyish uchun kulayli foydalniladi.
YOKI amalini bit operandida bajarayotganda 1 ma’nosiga tenng, bo’nga mos ma’nosi xam 1 ga
teng bo’ladi.
Masalan :
1101 001
1010 1010
&________
111011
YOKI razryad operatorining yokoridagi keltirilgan dasto’rni tok sonlarni olish uchun xam
keltirsa xam buladi.
G’G’ YOki razryad operatorini xoxlagan jo’ft sonini tok soniga
G’G’ «aylantirish » da foydalanishi
using System;
class MakeOdd { public static void
Main ( ) { ushort num; ushort i;
for ( i q 1; i
num q i ;
Console. WriteLine (“ num: ”Q num);
Num q (ushort ) ( “num : “ Q num);
num q (ushort ) ( num I 1); G’G’ num| 0000 0001
Console. WriteLine ( “ num ga kichik bitni kuygandan so’ng: “
Q num Q “g’ n”) ;
Bu dasto’rning natiyjasi kuyidagicha
num 1
num kichkina bitni olib tashlangandan so’ng : 1
num 2
num kichkina bitni olib tashlangandan so’ng : 3
num 3
num kichkina bitni olib tashlangandan so’ng : 3
num 4
num kichkina bitni olib tashlangandan so’ng : 5
num 5
num kichkina bitni olib tashlangandan so’ng : 5
num 6
num kichkina bitni olib tashlangandan so’ng : 7
num 7
num kichkina bitni olib tashlangandan so’ng : 7
num 8
num kichkina bitni olib tashlangandan so’ng : 9
num 9
num kichkina bitni olib tashlangandan so’ng : 9
num 10
num kichkina bitni olib tashlangandan so’ng : 11
Bu dasto’rning ishi YOKI razryad operatorining ketma-ket sonlar orasida va 1 soni ikkilik
kodida 0000 0001 turida keltiriladi. Shunday kili, 1- bo’ ma’noda fakat kichik razryad kuyilgan.
Agarda, bu ma’no YOKI amalining ba’zi bir ma’nosi bo’lsa, unda bu amalning natiyjasi ikkinchi
operand Bilan tuxri keladi uning kichik razryadidan tashkari , ya’ni u 1 teng bo’ladi ( xolgan
xammasi o’zgarmiydi). Shunday kilib, xoxlagan jo’ft son YOKI opertoridan « utib» bir soniga
kupayadi, ya’ni tok soni bo’ladi.
YOKI razryad kiskarto’vchi ( OR) bitga birni ko’yadi fakatgina natiyjasi bir-biridan fark kilsa
gina, ya’ni teng emas.
Masalan:
0111 1111
1011 1001
________
1100 0110
OR operatori o’zgacha bir xossaga ega, va uni kodlashda foydalaniladi. Agarda, OR amalini X
ukish va Y ma’nosi orasida bajarsak, va OR amalini birinchi operatsiyasi Bilan Y ma’nosi orasdi
foydalansak, unda X ning oldingi ma’nosini olamiz. Bu deganimiz ikkita amalni bajargandan
so’ng
R1 q X → Y ; R2 q R1 →Y ;
R2 ning ma’nosi X ma’nosi bilan barobar bo’ladi. Shunday kilib, ketma-ket OR amalini
ishlatgandan so’ng, Y- ning bir xil ma’nolarni foydalangandan so’ng X-ning ma’nosi chikadi. Bu
prinsipni oddiy shifrlashda foydalansa bo’ladi, unda ba’zi bir ma’no - kaliti – axborotni kodlash
va kodni ochishda yordam beradi. YOKI kiskarto’vchi amali shifrlashda birinchi marotaba
foydalaniladi, a kodni ochishda ikkinchi marotaba foydalaniladi. Bu oddiy uslubni kuyidagi
dasto’rda ko’rib utamiz:
G’G’ OR operatorini axborotni shifrlashda
va shifrlanganni ochishda foydalanishi.
using System;
class Encode {
public static void Main( ) {
char chl ‘ H1; char ch2 ‘1’ ; char ch3 –‘1’
int key q8.8;
Console. WriteLine (“ Oldingi axborot : “ Q
chl Q ch2 Qch3 );
G’G’ Axborotni shifrlaymiz. ch1q
(char) (ch1 A key); ch2 q
(char) (ch2 - key); ch3 q
(char) (ch3 A key);
Console. WriteLine (“ Shifrlangan axborot : “ Q
chl Q ch2 Qch3 );
G’G’ shifrlangan axborotni ochamiz;
ch1q (char) (ch1 l key);
ch2 q (char) (ch2 A key);
ch3 q (char) (ch3 l key);
Console. WriteLine (“ Shifrlangan axborotni ochilgani : “ Q
chl Q ch2 Qch3 ); } }
Bu dasto’rning natiyjasi kuyidagicha:
Bor bulgan axborot : Hi!
Shifrlangan axborot :
> 1y Shifrlanganni ochilgan axborot:
Hi!
Kurib turganingizdek, OR amalaining ikki marotaba foydalanilishi, bir kalitning ma’nosini
ikkalasinda xam foydalanilishida shifrlanganni ochilgan axborotni olamiz.
YUK unar operatori ( yoki I gacha to’liktirilgan operator) uzining operandining xamma
bitlarining xolatini tekshiradi. Masalan, agarda butunsoni ma’no ( A o’zgaruvchida
saklanadigan) ikkilik kodini tashkil etadi 1001 0110, A-amalining natiyjasida ikkilik kodini
olamiz 0110 1001.
Endigi dasto’rda YUK operatorining ba’zi bir soni 1 ga to’liktirilganincha ikkilik kodida
ko’rsatiladi.
G’G’ YUK operatorining foydalanilishi
using System;
class Not Demo { public static void
Main( ) {
Sbyte to q -34
int t;
for ( t-128; t > 0; t q tG’2 ) {
if (( b & t ) 1q0) Console.Write C “1”);
if (( b & t ) - 0) Console.Write ( ”0”);
Console. WriteLine ( );
G’G’ Barcha bitlarni tekshiramiz,
bq(sbyte)  b;
for ( t q 128; t > 0; t q tG’2) {
if (( b & t ) 1q0) Console.Write C “1”);
if (( b & t ) –i 0) Console.Write ( ”0”);
}}} Bo’ dasturning natiyjasi kuyidagicha
110111
10
001000
01
Siljitish Operatorlari.
S# da ma’nolarni berilgan son razryadiga ko’ra uni unga va chapka siljitishga bo’ladi.
Uning uchun S # da kuyidagi razryadli siljitish operatorlari belgilangan : << chapka siljiish; >>
unga siljitish. Shu operatorlarning yozilish umumiy formati kuyidagicha:
Ma’no << bitlar^ soni;
Ma’no >> bitlar^ soni;
Bo’ yerda ma’no - bu siljitish operatorining ob’ekti , a element bitlar^ soni esa kancha raryad
soniga siljitishini kursatish kerak.
Chapka bir razryadga silijitishda xamma bitlar bir poziiya chapka siljiydi, a eng kichik razryadga
nul ma’nosi kuyiladi. Ungda tarafga siljitganda xamma bitlar mos ravishda ungga siljiydi.
Agarda ung tarafga siljitganda belgisi yuk ma’nosi tugri kelsa, unda katta razryadga nul ma’nosi
yoziladi. Agarda ung tarafga siljitganda belgisi bor ma’nosi tugri kelsa, unda razryadga belgilari
saklanib koldiriladi. yeslab kuring: manfiy butun sonlar katta razryadning birga barobar Bilan
kursatiladi. Sho’nday kilib, agarda siljitayotgan son ma’nosi manfiy bo’lsa, unda xar bita
siljitishda katta razryadga 1 ma’nosi kuyiladi, agarda musbat bo’lsa unda -0 kuyiladi.
Unga va chapga siljitishda chetki bitlar yukoladi. Shunday kilib, bu yerda siklli emas sijtish
bajariladi va bitningyukolgan ma’nosini bilsa bo’ladi.
kuyidagi dasto’rda unga va chapka siljitishi ko’rsatiladi. Siljitishdagi ma’no birga teng deb
olinadi, ya’ni fakat kichik razryad ma’nosi « start boshlangandan» 1 ga teng buladi, a kolganlari
esa 0 ga teng buladi. Xar bir sakkiz chapka siljitishni bajargandan kegin dasturda kichik sakkiz
razryadni kursatadi. Kegin kursatilgan protsess kaytalanadi.
Endigi paytda val uzgaruvchisiga 1 kuyilmaydi 128 kuyiladi va u ikkilik kodida
1000 0000 yoziladi. Va albatta siljitish endi chapka emas a unga siljitiladi.
G’G’ << VA >> Siljitish operatorining foydalanilishi.
using System;
class ShiftDemo { public static void
Main( ) { int val q 1;
int t;
int i;
for ( i -0; i < 8; iQQ ) {
for (tq128; t > 0; t q tG’2 ) {
if (( val & t ) 1q0) Console.Write ( “1”);
if (( val & t ) qq 0) Console.Write C ”0”}; }
Console. WriteLine { ); val - val « 1; G’G’ Chapka siljitish.
}
Console.Write ( );
Val q128;
for ( i q0; i < 8; iQQ ) {
for ( tq128; t > 0; t q tG’2 ) {
if (( val & t ) 1q0) Console.Write ( “1”);
if (( val & t ) qq 0) Console.Write C ”0”);
Console.WriteLine ( );
Val q val » 1; G’G’ Ungga siljitish
bo’ dasturning natiyjasi Quyidagicha
00000001
00000010
00000100
00001000
00010000
00100000
01000000
10000000
10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
Ikkilik sonak sonlar razryadlari 2 sonini darajasini tashkil etadi, unda siljitish operatorlarini 2 ga
kupaytirish yoki bulishda foydalansa buladi. Albatta bu tugri bo’ladi agarda birinchi yoki
ikkinchi tarafdan ( yukoladi) ma’noli bitlar kursatilmasa.
Masalan:
G’G’ Ciljitish operatorlarini 2 ga kupaytirishda yoki
bulishda foydalanilishi.
using System;
class Mult Div
{ public static void Main( ) {
int n;
nq10;
Console. WriteLine ( « n o’zgaro’vchining ma’nosi: « Q n);
G’G’ 2 ga kupaytiramiz n qn << 1;
Console.WriteLine ( “ n o’zgaro’vchisining ma’nosi nqn*2: “ Q n dan kegin);
G’G’ 4 ga kupaytiramiz n qn << 2;
Console.WriteLine ( “ n o’zgaro’vchisining ma’nosi nqn*4: “ Q n dan kegin);
G’G’ 2 ga bo’lamiz n qn << 1;
Console.WriteLine ( “ n o’zgaro’vchisining ma’nosi nqnG’2: “ Q n dan kegin);
G’G’ 4 ga bo’lamiz;
Console.WriteLine (
“ n o’zgaro’vchisining ma’nosi nqnG’4: “ Q n dan kegin);
Console.WriteLine ( );
G’G’ Oldingi xolatini keltiramiz;
Console.WriteLine ( “ n o’zgaro’vchisining ma’nosi : “ Q n );
G’G’ 30 marotaba 2 ga kupaytiramiz.
nqn<
Sonsole.WriteLine (
” n o’zgaro’vchisining ma’nosi 30 razryadga chapka siljitish : “ Q n);
bo’ dasturning natiyjasi kuyidagicha
n o’zgaro’vchining ma’nosi: 10;
n o’zgaro’vchisining ma’nosi nqn*2: dan kegin 20;
n o’zgaro’vchisining ma’nosi nqn*4: dan kegin 80;
n o’zgaro’vchisining ma’nosi nqnG’2: dan kegin 40;
n o’zgaro’vchisining ma’nosi nqnG’4: “ dan kegin 10;
n o’zgaro’vchisining ma’nosi : 10;
n o’zgaro’vchisining ma’nosi 30 razryadga chapka siljitgandan sung: -214748364 8
Itibor beringki, dasturning oxirgi katori bajarilgannan kegin natiyjasiga.
10 sonini chapka 30 razryadga siljitgandan so’ng ( ya’ni 2 ga kupaytirilgannan kegin) axborotlar
yukoladi, sababi int tipiga ajratilgan shu sonning ma’nosi kursatilgan diapazonnan tashkarisida
kursatilib turibdi. Xozir siz sonning manfiy ma’nosini krib turibsiz va bu katta razryadga bir
kuyilishidan kelib chikadi a bo’ esa int tipii uchun belgi sifatia foydalaniladi. Shuning natiyjasida
son manfiy sonbo’lib kabil etilgandek bo’ladi. Bu dasturdan kurinib turibdiki 2 ga kupaytirishda
yoki bulishda ixtiyotkorlik bilan siljitishni bajarish.
Razryadli uzlashtirish murakkab operatorlari.
Barcha binar razryadli operatorlarini uzlashtirish operatorlari bilan biriktirsa bo’ladi.
Masalan kuyidagi ikkita instruksiyada x o’zgaruvchisiga YOKI ( OR) kiskaruvchi operandlari
bilan x va 127 ni uzlashtiradi.
Xqx *127; xl q127;
VA ? operatori
S# da eng kulay operatorlarining biri bo’ trenar ?- operatori bo’lib xisoblanadi.
? – Operatori kupincha belgilangan konstruksiya tipini almashtirish uchun foydalaniladi if- then
– else. ?- Operatori trenar operatori deb aytiladi, sababi u uchta operator Bilan ishlaydi. Uning
umumiy format yozilishi kuyidagi turga ega:
Ifoda 1 ? Ifoda 2 : Ifoda 3;
Bu yerda ifoda 1 bool tipida bulishi kerak. Ifoda2 va Ifoda3 element tiplari bir xil bulishi kerak.
Itibor beringki xo’sh nuktaning joylashishi va foydalanishiga
? Ifoda ma’nosi kuyidagicha aniklanadi. Ifoda 1 xisoblanadi. Agarda uning ntaiyjasi xakikiy
bo’lsa ifoda2 bajariladi va uning natiyjasi xamma ?-ifoda uchun ma’nosi buladi. Agarda Ifoda1
elementining xisoblash natijasi yolgon bo’lsa, unda barcha ?Ifoda ma’nosi Ifoda3 elementining
xisoblash natiyjasi buladi. Masala kurib utamiz abs val uzgaruvchisiga val uzgaruvchisining
absolyut ma’nosi kuyiladi.
Absvalq val < 0 ? – val; G’G’ val ma’nosining absolyut ma’noni olamiz .
Bu yerda absval uzgaruvchisiga val uzgaruvchining ma’nosi uzlashtiriladi, agarda u nuldan
ulkan yoki kichik bulsa. Agarda val uzgaruvchisining ma’nosi manfiy bulsa absval
uzgaruvchisiga «unar minusi » uzlashtiriladi, va u musbat ma’noga ega.
? operatori foydalanishi tugrisida yana bir masalani kurib utamiz.
Bu dasturda 100 sonini xar xil sonlarga bulinishini kurib utamizya, lekin nulga bulishi
kuzatilmaydi.
G’G’ ? Operatori yordamida nulga bulishni aylanib utish uslubi.
Using System;
class NoZeroDiv { public static void
Main( ) { int i ;
for iq-5 ; i < 6; iQQ ) {
result >> i1q0? 100G’i : 0 ;
if (i 1 -0 )
Console. WriteLine ( “ 100G’ “ Qi “ teng “ Q result ); }
}
ushbu dasturning bajarilishi natiyjalariga karang.
100.
G’ -5 teng – 20
100.
G’ -4 teng - 25
100.
G’ - 3 teng – 33
100.
G’ - 2 teng -50
100.
G’ - 1 teng -100
100.
G’ 1 teng 100
100.
G’ 2 teng 50
100.
G’ 3 teng 33
100.
G’ 4 teng 25
100.
G’ 5 teng 20
Shu dasturdagi keyingi katorga karang
I result q I !q 0 ? 100 G’ i : 0;
Bu yerda result uzgaruvchisiga 100 sonini i uzgaruvchisining j ma’nosiga bulish natiyjalari
uzlashtirilgan. Lekin bu amal i nulga teng bulmagan xoldagina bajariladi. Teskari xolda (agar
iq0) result uzgaruvchisiga nul ma’no beriladi.
Xakiy xatda ? operatori tamonidan uzgaruviga ma’no berish shart emas. Misol uchun, siz bu
ma’noni usunilgan uslubning argumenti sifatida kullanishingiz mumkin. YAna bir shu kabi
variant imkoniyati bor. Agar ? operatori tomonidan kabul kilingan ifodalar bool tipiga ega bulsa,
unda bu operatorning bajarilish natiyjalarini sikldagi yoki if instruksiyasidagi shartli ifodalar
sifatida kullash mumkin. Avvalgi dasturni ancha ixcham turida karab utaylik (uning bajarilish
natiyjalari avvalgisiga tugri keladi).
G’G’ ? operatori yordamida nulga bulishni aylanib utish.
Using System;
class NoZeroDiv { public static void
Main( ) { int i ;
for ( iq-5 ; i < 6; iQQ ) if (i 1qq0 ? true: false
Console. WriteLine ( “ 100G’ “ Qi Q“ teng “ Q 100G’i ); > }
}
if instruksiyasiga itibor bering. Agar i uzgaruvchisining ma’nosi nulga teng bulsa if tekshirish
natiyjalari – false ma’nosiga teng buladi, u esa chikarish instruksiyasining bajarilishini uzaga
keltirmaydi, demak nulga bulishni xam. Aksi xolda bulish (natiyjani chikarish bilan) uzaga
keladi.
Probel va kovuslarni foydalanilishi.
S# dagi xoxlagan ifodaga kulaylashtirish uchun probel (eki tabulyatsiya simvollarini) kiritsak
buladi. Masalan, keiyngi ikkita ifoda bir xil, lekin ikkinchisi ancha kulayrok yozilgan.
x q 10G’y*(127G’x); x q 10G’y*(127G’x);
Doyra shaklli kovuslar( algebradagidek) amallarning bajarilishini oshiradi. YOrdamchi
kovuslarning foydalanilishi xatoga yeki xisoblashni sekinlashtirishga olib kelinmaydi. Bir gap
Bilan aytganda ulardan foyda kuprok. Aytingchi, masalan shu ikki ifodadan kaysi birini
tushinishi ason
x-yG’334* tempQ127 ; Xq(yG’3)-(34*temp) Q127;
11 Operatorlarning prioriteti.
4.2 jadvalda S# operatorlarning bajarilish tartibi keltirilgan( eng kattasidan eng kichigigacha
bulgan)
4.2 Jadval S# - operatorlarning prioriteti .
( ) [ ] . QQ( postfiksli) cheked new size of type of unchecked
! Tipni keltirish operatorlari Q{ unar )–( unar) QQ(prefiksli)-( prefiksli)
*G’ %
Q«»
<< q >>q is
&
is
||
?:
q opq
Bu bopta S# tilining dasturlashda bajarilishning boshkarish instruksiyalari karaladi. Boshkarish
istruksiyalarning uchta kategoriyalari bor: tanlash instruksiyasi ( if switch ), iteratsion
instruksiyalari ( for, while, dowhile va foreach-sikllaridan iborat) va uzatish intsruksiyasi ( beak,
continue, goto, return va throw). Throw instruksiyasidan tashkari, sababi u C# tilining kayta
ishlash mexanizmining ayrikcha xolati buladi, kolgan yukorida keltirilgan instruksiyalari shu
bopda kursatilgan.
U if - Instruksiyasi
If instruksiyasi 2 bopda keltirilgan edi, lekin bu yerda biz kegrok kurib utamiz.
Uning yozilish tulik formati shunday buladi:
If ( shart) instruksiya;
Else instruksiya;
Bu yerda instruksiya elementi deb bitta instruksiya tushilinadi. Else kismi esa shart emas.
Instruksiya elementi urninda blok instrukiyasi foydalanilishi mumkin. Bu paytda if
instruksiyasining yozilish formati kuyidagicha buladi.
If ( shart) |
Instruksiyalar ketma- ketligi
Else {nstruksiyalar ketma- ketligi )
Agarda shart elementi ya’ni shartli ifodani tashkil etadigan, xisoblashda XAKIYKAT ma’nosini
beradigan if- instruksiyasi foydalaniladi, aksi xolda else-instruksiyasi foydalaniladi( agarda u
mavjo’d bulsa). Ikkala instruksiyasi birgalikda bajarilmaydi. If – instruksisi bilan bajarilgan
boshkarish bool tipida bulishi kerak.
Oddiy bir asturni kurib utamiz, unda if-else instruksiyalari sonning manfiy yoki musbat son
ekanligin aniklashda foydalaniladi.
G’G’ Dasturda berilgan son manfiy yoki musbat son ekanligin kursatadi.
Using System;
class PosNeg { public static void
Main( ) )
int i ;
for iq-5 ; i < q5; iQQ ) {
Console. WriteLine ( “ testdan utkazish “ Q i Q “: “ );
if i< 0 ) Console. WriteLine ( “ Con manfiy “ );
}
Dasturning bajarilishi kuyidagi kurinishda buladi.
Testdan utkazish -5: Manfiy son
Testdan utkazish -4: Manfiy son
Testdan utkazish -3: Manfiy son
Testdan utkazish -2: Manfiy son
Testdan utkazish -1: Manfiy son
Testdan utkazish 0 : Musbat son
Testdan utkazish 1 : Musbat son
Testdan utkazish 2 : Musbat son
Testdan utkazish 3 : Musbat son
Testdan utkazish 4 : Musbat son
Testdan utkazish 5 : Musbat son
Agarda bu mashkda i- uzgaruvchisining ma’nosi nuldan kichik bulsa, if - instruksiyasi bajariladi
( « diagnoz » kiritiladi: Son musbat deb). Ikkita instruksiya birgalikda bajarilmaydi.
If ustma ust kuyilgan instruksiyalari .
If- ustma-ust kuyilgan nstruksiyalari tashkil etiladi, agarda element intsruksiyasi urniga if –
instruksiyasi foydalanilsa. Ustma-ust if –instruksiyasi dasturlashda kengdan foydalaniadi. Eng
asosiysi else - intsruksiyasi yakin turgan if instruksiyasiga oyd ekanini bilsangiz va u dasturning
shu blokida buladi.
Masalan:
if ( i -10) {
if ( j < 20) a q b;
if ( k > 100) c qd; - else aqc; G’G’ Bu else – instruksiyasi
G’G’ if –instruksiyasiga tegishli (k>100).
}
else a q d; G’G’ Bu else- instruksiyasi if- instruksiyasiga tegishli (iqq10).
Aytilgandek, else – instruksiyasi if ( j < 20) – instruksiyasi bilan boglik emas, sababi ular bir
blokda emas( if- instruksiyasi – yakin turganina karamasdan, u else-jo’ftligiga ega emas).
Ichki else-instruksiyasi if ( k >100 )- instruksiyasi bilan bolik, sababi u yaxin joylashgan va shu
blokning ichida.
G’G’ Dasturda berilgan son manfiy yoki musbat son ekanligin
yoki nulga teng ekanligin kursatadi.
Using System;
class PosNeg { public static void
Main( ) {
int i ,for iq-5 ; i < q5; iQQ ) {
Console. Write ( “ testdan utkazish “ Q i Q “: “ );
if ( I < 0 ) Console. WriteLine ( “ Con manfiy “ );
else if ( i q 0 ) Console. WriteLine ( “ Con belgisi yuk “ );
else Console. WriteLine ( “ Con musbat“ );
}
}
}
Dasturning natiyjasi kuyidagi kurinishda buladi.
Testdan utkazish -5: Manfiy son
Testdan utkazish -4: Manfiy son
Testdan utkazish -3: Manfiy son
Testdan utkazish -2: Manfiy son
Testdan utkazish -1: Manfiy son
Testdan utkazish 0 : belgisi yuk son
Testdan utkazish 1 : Musbat son
Testdan utkazish 2 : Musbat son
Testdan utkazish 3 : Musbat son
Testdan utkazish 4 : Musbat son
Testdan utkazish 5 : Musbat son
If – Else – If Konstruksiyasi
Dasturlashda eng kup tarkalgan konstruksiya, va uning asosida ustma- ust if – instruksiyasi «
zina» dek if – else – if bor buladi . Uni keyingi dasturda kurib utsak buladi:
If ( shart)
Instruksiyasi;
Else-if (shart)
instruksiyasi;
Else if { shart)
Instruksiyasi;
Else
Instruksiyasi;
Bu yerda shart elementi deb shartli ifodani tushinsa buladi. Shartli ifodalar tepadan pastga xaray
xisoblanadi. Fakat kaysi tarafda xakikiy natiyja joylashilgani bilinsa, va bu taraf bilan boglik
bulgani aniklansagina, a bosha tarafi «Zina» koldirilib ketiladi.
Agarda, bittayam sharti akiykiy emasligi aniklansa, unda oxirgi else-instruksiyasi bajariladi (va
uni shartni kursatilmagan xolatda bajarilayabdi deb xisoblasa xam buladi). Agarda oxirgi elseinstruksiyasi berilmagan bulsa, a kolgan instruksiyalari yolgon bulsa u paytda xech bir amal
bajarilmaydi.
if – else – if «Zina» ning ishi kuyidagi dasturda kurilib utiladi va u berilgan ma’noga eng kichik
kupaytiruvchi kiymatini kursatib beradi ( 1dan uzgacha va bir sifradan iborat).
G’G’ bir sonidan iborat eng kichik
G’G’ kupaytiruvchi kiymatini aniklash
Using System;
class Ladder { public static void
Main( ) {
int rmra;
for ( num q2; num
iff ( num % 2) -0)
Console. WriteLine (( “ Eng kichik kupaytiruvchi son “ Q num Q “teng 2. “ );
else iff ( num % 3) qq0)
Console. WriteLine (( “ Eng kichik kupaytiruvchi son “ Q num Q “teng 3. “ );
else iff ( num % 5) qq0)
Console. WriteLine (( “ Eng kichik kupaytiruvchi son “ Q num Q “teng 5. “ );
else iff ( num % 7) qq0)
Console. WriteLine (( “ Eng kichik kupaytiruvchi son “ Q num Q “teng 7. “ );
else
Console. WriteLine (( num Q “ 2, 3, 5 yoki 7 ga bulinmaydi “); }
}
}
}
Dasturning natiyjasi kuyidagi kurinishda buladi.
Eng kichik kupaytiruvchi son 2 teng 2 ga.
Eng kichik kupaytiruvchi son 3 teng 3 ga.
Eng kichik kupaytiruvchi son 4 teng 4 ga.
Eng kichik kupaytiruvchi son 5 teng 5 ga.
Eng kichik kupaytiruvchi son 6 teng 6 ga.
Eng kichik kupaytiruvchi son 7 teng 7 ga.
Eng kichik kupaytiruvchi son 8 teng 8 ga.
Eng kichik kupaytiruvchi son 9 teng 9 ga.
Eng kichik kupaytiruvchi son 10 teng 2 ga
11 soni 2, 3, 4, 5 yoki 7 ga bulinmaydi
Kurib turganingizdek else –instruksiyasi fakatgina ishlatiladi, agarda oldingi xech bir ifinstruksiyalari bajarilmasa.
Switch instruksiyasi
Ikkinchi tanlash instruksiyasi bulib xisoblanadi. Switch isntruksiyasi kup yunaltirilgan
tarmoklanishni ta’minlaydi. U kupchilik alternativadan bittasini tanlashga yordam beradi.
Kupyunaltirilgan testdan utkazishda ustma-ust if- instrksiyasida xam bajarsa xam bular edi, lekin
switch instruksiyasi yordaminda kupchilik xolatlarda instruksiyasi effektiv yechimi buladi. Bu
esa kuyidagicha ishlaydi. Ifoda ma’nosi ketma-ket konstantalar bilan solishtiriladi. Agarda,
solishtirishda shartlardan bittasi tugri kelsa shu shart bilan boglik ketma-kteligi bajariladi. Switch
instruksiyasining umumiy yozilish formati kuyidagicha:
Shwitch (ifoda) {
Case konstanta ! :
instruksiya ketma - ketligi
break ; case konstanta 2:
instruksiya ketma - ketligi
break ;
case konstanta 3: instruksiya
ketma - ketligi break;
default:
instruksiya ketma - ketligi break;
}
Switch isntruksiyasining ifoda elementi butunsonli tipda bulishi kerak ( masalan, Char, byte,
short, yoki int) yoki string ( keyinda bu tugrisida so’z yuritamiz). Suzuvchi nukta Bilan ifodalar
foydalanilmaydi. Kupincha Switch ifodasi boshkarish uchun uzgaruvchi foydaliniladi, case –
konstantalar literlar bulishi shart, va ularding tiplari berilgan ifodalarning tiplari bilan tugri
kelishi kerak. Va shu inobatda ikkita case- konstantalari bir Switch-isntruksiyasi bir xil ma’noga
ega bulmaydi.
Default-tarmoklari instruksiyasi ketma- ket bajariladi, agarda berilgan case-konstantalarining
bittayam natiyjalari switch-ifodasining ma’nolari tugri kelmasa.
Default -tarmogi shart emas. Agarda, ifodaning natiyjalari tugri kelmasa case-konstantalari
ma’nosi bilan unda xech bir amal bajarilmaydi. Agarda, shunaka ma’nosi tugri kelsa, unda case –
instruksiyasi tarmokiga mos instruksiyasi bajariladi, break- instruksiya uchratilmagancha.
Switch isntruksiyasi foydalanilishi kuyidagi dasturda kursatiladi.
G’G’ Switch isntruksiyasi foydalanilishi kursatamiz.
Using System;
class ShwitchDemo { public static void
Main( ) { int i;
for ( iq0 ; i
switch ( i ) { case 0:
Console. WriteLine (( “ i “ nulga teng “ );
Break;
Case 1:
Console. WriteLine (( “ i “ nulga teng “ );
Case 2 :
Console. WriteLine (( “ i “ ikkiga teng “ );
Case 3:
Console. WriteLine (( “ i “ uchga teng “ );
Case 4:
Console. WriteLine (( “ i “ turtga teng “ );
Break;
default:
Console. WriteLine (( “ i “ teng yoki beshtan ulkan “ );
Dasturning natiyjasi kuyidagi kurinishda buladi.
Console. WriteLine (( “ i “ nulga teng “ );
Dasturning natiyjasi kuyidagi kurinishda buladi.
i nulga teng.
i ikkiga teng.
i uchga teng.
i turtga teng.
i teng yoki beshtan ulkan.
i teng yoki beshtan ulkan.
i teng yoki beshtan ulkan.
i teng yoki beshtan ulkan.
i teng yoki beshtan ulkan.
Kurib turganingizdek siklning xar bir iteratsiyasida instruksiyalar bajariladi, sase-konstantalarga
mos ravishda va u i- uzgaruvchisisning ma’nosi bilan tugri keladi. Shu inobatda kolgan barcha
isntruksiyalar koldiriladi. Agarda 1ga yoki beshtan ulkan bulsa, default- instruksiyalari
bajariladi.
Oldingi misolda switch – instruksiyasi int tipidagi uzgaruvchi bilan boshkarilsa. Kurib
turganingizdek switch – instruksiyasini bosharish uchun xoxlagan butunsonli tipdagi
uzgaruvchini foydalansa buladi, va char tipindagi uzgaruchini xam.
Misol case – tarmoklarida shar- ifodani va char- konstantani foydlanilishi.
G’G’ Char tipining switch – instruksiyasini
boshkarishda foydalanilishi.
Using System;
class ShwitchDemo2 { public static void
Main( ) { char ch;
for ( ch q ‘A “; ch
switch ( ch ) { case ‘A’:
Console. WriteLine ( “ch A dan iborat “ );
break;
case ‘ B ’ :
Console. WriteLine ( “ ch B dan iborat “ );
Break;
case ‘ C:
Console. WriteLine ( “ ch S dan iborat“ );
Break;
case ‘ D:
Console. WriteLine ( “ ch D dan iborat“ );
Break;
case ‘ E:
Console. WriteLine ( “ ch E dan iborat“ );
Break;
Dasturning natiyjasi kuyidagi kurinishda buladi.
Ch A dan iborat
ch B dan iborat
ch S dan iborat
ch D dan iborat
ch E dan iborat
Itibor beringki, bu misolda default-instruksiyasi yuk. Va shart emasligini unutmang. Agarda,
bunga zarurot bulmasa uni koldirib ketsada buladi.
C # da xato bulibxisoblanar edi agarda, case-tarmogining bittasiga kiradigan bulsa, keyingi
ketma - ketlik instruksiyasiga utadi. Bu yerda boshkarishni pastga kuchishi man etilgan koydasi
bor bulishi kerak, dasturchilar aytishi buyicha. Shuning uchunda sase-ketma-ketligi break
instruksiyasi bilan tugaydi.( «Yukotish» boshka chora bilan kursa xam buladi, masalan goto –
instruksiyasi bilan xam, lekin eng kupincha break foydalaniladi).
Break- instruksiyasi sase- instruksiyasini yakunlavchi ketma ketlik, switch kostruksiyasidagilarni chikishga olib keladigan, va boshkarish instruksiyasini keyingi instruksiyasiga uzatuvchi,
switch konstruksiyasidan tashkarisida joylashuvchi. Default- tarmogi instruksiyasining ketmaketligi «yukolib » ketmasligi kerak va break- instruksyasi bilan yakunlashi kerak.
Boshkarishning pastga uzatish « Yukotish» man etilgan koydasi bu S # tilining bir uzgachiligi,
boshka tillarga karaganda S, SQ Q va Java. Shu aytilgan uch tillarda « sekin» keiyngi
instruksiyaga utish xukkiga ega keingi case-tarmogi instruksiyasiga mos, S # tilini yaratuvchilar
« yukotish» chek kuygan ikii sababiga kura. Birinchidan bu kompilyatorga optimizatsiya
maksadida case-tarmogining utish tartibini bemalol uzgartsa buladi, agarda, bitta case-ketmaketligi xech kanak tusiksiz keyingiga utishish mumki n emas. Ikkinchidan, case-ktemaketligining anik tugatilishi talabi maxsus instruksiyasi bilan tusatdan « yukotish» imkoniyatini
yukotadi dasturchining bilmasdan yaratganligidan.
« Yukotish » mann etilaginiga karamasdan boshkarishni case- ketma- ketligidan keiygiga
uzatilishi mumkin, keyingi misolda kursatilagandek dasturiy kod tashkil etsak buladi, iikita yoki
undan kuprok case- instruksiyalari shu tashkil etilgan kodga yunaltirilsa buladi.
G’G’ «Bush » case-instruksiyalari « yukolishi» mumkin .
Using System;
class EmptyCasesCanFall { t public
static void Main( ) {
int i;
for ( i-1; i
Console. WriteLine ( “ i teng 1, 2 yoki 3“ );
break; case 4 : Console. WriteLine ( “ i teng 4 “ );
break; );
)
}
Shu dasturning natiyjasi kuyidagi kurinishda buladi.
i teng 1, 2 yoki 3
i teng 1, 2 yoki 3
i teng 1, 2 yoki 3
i teng 4
Agarda, bu misolda i uzgaruvchisi 1,2 yoki 3 teng bulsa, unda WriteLine chakirish
usuilining birinchi instruksiyasi bajariladi ( >, agarda i ma’nosi 4 ga teng bulsa, unda ikkinchi
instruksiyasi bajariladi. Bu yerda kursatilgan case-tarmogi paketlashtirish
« yukotish» koydasini yukotmaydi, sababi, xamma case – instruksiyalari bita kodlik ketma –
ketligini foydalanadi.
Shunday case-paketlashtirish -eng tarkalgan uslub, kodlarni birgalikda foydalanish bir
nechcha case – tarmogi bilan, kerak emas kodlangan ketma- ketlikni olib tashlash
imkoniyatiga ega.
Switch ustma-ust instruksiyalari
Switch instruksiyasi case- ketma ketligining bir kismi bulib foylanilishi mumkin tashki Switch
instruksiyasining. Bu paytda u ustma- ust Switch instruksiyasi deb ataladi. Aytib utish joyzki
ichki va tashki Switch instruksiyasi case-konstantalari bir xil ma’noga ega bulii mumkin, va xech
kanaka uzgarish ega bulmaydi.
Masalan, kodning keyingi fragmenti mumkin buladi.
Shwitch(ch1) { Case ‘A’ :
Console. WriteLine (
“Bu A xarfi – switch instruksiyasining bir kismi.”);
Shwitch(ch2) { Case ‘A’ :
Console. WriteLine (
“Bu A xarfi – ichki switch instruksiyasining bir kismi.”);
break;
case ‘ B ’ : G’G’…
break ; case ‘ B’ : G’G’ …
G’G’ switch ichki instruksiyasining yakunlanishi.
Ikkinchi bopdan boshlab for siklining oddiy shakilida foydalandik. Shub bopta endi bu siklni
maydalab kurib utamiz. For siklining umumiy yozilish formati bitta instruksisini kayta
ishlashdagi kuyidagi turda buladi: e
for (initsializatsiyalash; shart, iteratsiya ) instruksiyasi;
agarda, for sikli dasturiy blokda, kayta ishlash uchun belgilangan bulsa uning umumiy formati
kuyidagicha buladi:
for (initsializatsiyalash; shart, iteratsiya )
{
instruksiyalar ketma- ketligi
Initsializatsiya elementi kupincha uzlashtirish instruksiyasini bildiradi, siklni boshkarish
uzgaruvchisini belgilaydi, bosh ma’nosiga teng bulgan.
Bu uzgaruvchi schetchik xisobida ishlaydi va siklning ishini boshkaradi. Shart elementi esa bool
tipidagi uzgaruvchilarni kursatadi Bu testlash natiyjasida for siklni ishlaydi yoki
ishlamaydiganini aniklaydi. Iteratsiya elementi esa – bu ifoda sikli boshkaruvchi uzgaruvchining
ma’nosi kanaka uzgaradiganini xar bir siklda aniklab beradi. Itibor beringki for siklning xar bir
elementi nukta- veyrbul bilan ajralib turibdi. For sikli shart elementi kachon xakiykiy natiyjani
bermaganincha bajariladi. Agarda sharti yolgg’on bulsa, dasturning bajarilishi for siklidan
keyingi instruksiyaga beriladi.
For siklini boshkaruvchi uzgaruvchisi musbat usishi bilan kanday bulsa, unda manfiy ma’nosi
bilan xam uzgaradi. Masalan, keyingi dasturda 100 dan 100 dekrementi bilan 5 ga teng
diapazonida sonlarni chikaradi.
G’G’ For sikli manfiy usishi
G’G’ boshkaruvchi uzgaruvchisi bilan.
Using System;
class DecrFor { public
static void Main( ) ( int x ;
for x q 100; x> -100; xq-5)
Console. WriteLine (x);}
}
Shuni yodta tutish kerak shartli ifoda for siklining boshida tekshiriladi. Bu deganimiz, agarda
birinchi tekshirishimiz YOLgON ma’nosini bersa, unda sikl kodi birdan bajarilmaydi. Masalan:
For( count q10; count
Bu sikli umuma bajarilmaydi sababi, count uzgaruvchisiga kirish ma’nosi beshtan katta.
Bu shartli ifodani ( count
For sikli foydali fakat uning takrorlanish soni belgili bulsa. Masalan, keyingi dasturda ikkita For
siklini foydalanadi 2 dan 20 gacha bulgan odiiy sonlarini topishda.
Agarda son oddiy bulmasa, dastur uning eng katta kupaytiruvchisini kursatadi.
G’* Oddiy soni aniklash dasturi. Agarda son oddiy bulmasa,
dastur uning eng katta kupaytiruvchisini kursatadi. *G’
Using System;
class findPrimes { public static void
Main( ) ( int num ; int I ; int factor;
bool isprirae; for ( numq2; num
isprime q true;
factor q0;
G’G’ num uzgaruvchisi i ga koldiksiz bulinadi.
For (iq2; i
G’G’ agarda num uzgaruvchisi i ga kodiksiz
bulinadigan bulsa, unda num- oddiy son emas
isprime q falser – factor qi; 1 }
if (isprime)
Console.WriteLine (num Q “ - oddiy son.” );
Else
Console.WriteLine (“ sonning maksimal kupaytiruvchisi “ Q
num Q “ teng “ Q factor );
}}} bu dasturning natiyjasi kuyidagi turga ega buladi.
2 - oddiy son.
3 - oddiy son.
4 sonning maksimal kupaytiruvchisi 2 ga teng.
5 - oddiy son.
6 sonning maksimal kupaytiruvchisi 3 ga teng.
7 - oddiy son
8 sonning maksimal kupaytiruvchisi 4 ga teng.
9 sonning maksimal kupaytiruvchisi 3 ga teng.
10 sonning maksimal kupaytiruvchisi 5 ga teng.
11- oddiy son
12 sonning maksimal kupaytiruvchisi 6 ga teng.
13 - oddiy son
14 sonning maksimal kupaytiruvchisi 7 ga teng.
15- sonning maksimal kupaytiruvchisi 5 ga teng.
16-sonning maksimal kupaytiruvchisi 8 ga teng.
17- oddiy son
18 sonning maksimal kupaytiruvchisi 9 ga teng.
19- oddiy son
For sikli temasining variyatsisi
For sikli - C # ning eng yumshok instruksiyalarining biri bulib xisoblanadi, sababi, u katta
diapazondagi variatsiyani olishga imkon beradi.
Bir nechcha siklni boshkaruv uzgaruvchilarni foydalanish
For siklni boshkarish uchun ikki yoki undan kup uzgaruvchilarni foylansa buladi, bu paytda
initsializatsiya va ietratsiya instruksiyalari xar bir uzgaruvchi uchun nukta veyrbul Bilan
ajratiladi. Masalan,
G’G’ For siklida nukta verbulni foydalanish.
Using System;
{ public static void
Main( ) {
int i, j ;
for ( i-0 ; j-10; i< j iQQ, j-)
Console. WriteLine (( “ i va j : “ Q i Q “ “ Q j );
Shu dasturning natiyjasi kuyidagicha
i va j: 0 10
i va j: 1 9
i va j: 2 8
i va j: 3 7
i va j: 4 6
Bu yerda veyrbul bilan ikkita initsializatsiya instruksiyasi ajratilgan va ikkita iteratsion ifodasi.
Siklga kirishda ikkita uzgaruvchi initsializatsiyalanadi I va j. Xar bir iteratsiyani bajargannan
kegin I uzgaruvchisi inkrementirlanadi a j uzgaruvchisi dekrementirlanadi. Siklda bir necha
boshkarish uzgaruvchilarni foydalanish algoritmlarni kiskartirishga olib keladi.
Initsializatsiyalash va iteratsiya bulimida for siklida xoxlagan sonda instruksiyalarni foydalanish
mumkin . Eng ulkan va eng kichik kupaytiruvchilarni topish dasturini kurib utamiz ( masalan
100 soni uchun ) Itibor beringki, sikl tugash shartiga u ikki boshkarish uzgaruvchilari uz ichiga
oladi.
G’For siklida eng kata va eng kichik son
kupaytiruvchilarni topishda veyrbuldan foydalinish.
Using System;
Class Comma {
{ public static void Main( ) { f int i, j;
int smallest, largest i, j ;
int num ;
Smallest q largest q1;
for ( iq 2, j q numG’2 & ( j > -2); iQQ, j - ); {
if( (smallest -1 ) & (( num% i) qq0 )
Smallest q i;
if( (largest qq1 ) & (( num% j) qq0 )
largest –j ;
Console. WriteLine (( “Eng katta kupaytiruvchi : “ Q largest );
Console. WriteLine (( “Eng kichik kupaytiruvchi : “ Q smallest );
)
1
Shu dasturning natiyjasi kuyidagicha
Eng katta kupaytiruvchi : 50.
Eng kichik kupaytiruvchi : 2
For siklida ikkita uzgaruvchisini foydalanish, eng katta kupaytiruvchini va eng
kichik kupaytiruvchini topishga buladi. Eng kichik kupaytiruvchini topishda biz i uzgaruvchisini
foydalanamiz. Avval u 2ga yeng deb olinadi va inkrementirlanadi kachongacha uning ma’nosi
berilgan sonining yarmidan oshmagancha( u num uzgaruvchisida saklanadi). Eng katta
kupaytiruvchini aniklash uchun j uzgaruvchini foydalanmiz. Avval u berilgan sonining yarmiga
teng deb olinadi ( num uzgaruvchisida saklanadigan) va dekrementirlanadi kachongacha uning
ma’nosi ikkidan kam bulmagancha. I va j uzgaruvchilari uzlarining ma’nosiga yetmagancha sikl
ishlay beradi. Sikl tugagannan kegin ikkita kupaytiruvchilar topiladi.
Shartli ifoda.
Shartli ifoda bulib xoxlagan for siklni boshkaradigan uzgaruvchisi buladi, bool tipining
natiyjasini kelitiradigan. Masalan keyingi dasturda sikl done uzgaruvchisi Bilan boshkariladi.
G’G’ bool tipindagi xoxlagan ifoda siklning sharti bulishi mumkin;
Using System;
class for Demo {
public static void Main( ) {
int I,j bool done q false;
for ( iq0, jq100 ; done I Q Q , j - ) {
if ( i*i >q j ) done q true ;
Console. WriteLine ( “ I, j: “ Q i Q “ “ Q j “ );
}
}} Bu dasturning natiyjalari
I, j: 0 100
I, j: 1 99
I, j: 2 98
I, j: 3 97
I, j: 4 96
I, j: 5 95
I, j: 6 94
I, j: 7 93
I, j: 8 92
I, j: 9 91
I, j: 10 90
Bu misolda for sikli takrorlanadi kachongacha bool uzgaruvchisining ma’nosi true bulmagancha.
Bu uzgaruvchisiga true kuyiladi, agarda i uzgaruvchisining kvadrat ma’nosi j uzgaruvchining
ma’nosidan katta yoki teng bulsa.
Sikldi aniklashda elementlarning yuk bulishi.
C# da sikl nomida xoxlagan elementni koldirishga buladi ( initsializatsiya-shart- iteratsiya) yoki
birdan xammasi. Siklni aniklashda ba’zi bir elementlarning yuk bulishi kizikarli natiyjani berishi
mumkin. Keiyngi dasturni kurib utamiz:
G’G’ For siklning kismlarini tashkil etadigan
kismi bush bulishi mumkin.
Using System;
class Emptyl { public
static void Main( ) {
int i;
for ( i-0; I < 10; ) {
Console. WriteLine ( “Utish № “ Q i );
iQ Q;G’G’ Siklni boshkaradigan uzgaruvchini inkrementirlaymiz} } }
Bu yerda for siklning iteratsiya ifodasi yuk. Uning urniga I boshkaruvchi uzgaruvchisi bilan
inkrementirlanadi, sikl ichida bor bulgan. Bu deganimiz siklning xar bir takrorlanishida bir amal
bajariladi : I uzgaruvchisining ma’nosi 10 soni bilan solishtiriladi. I uzgaruvchisining ma’nosi
sikl ichida ikrementirlangani uchun, u u normal funksiyalanadi kuyidagi natiyjalarni kursatib.
Utish № 0
Utish № 1
Utish № 2
Utish № 3
Utish № 4
Utish № 5
Utish № 6
Utish № 7
Utish № 8
Utish № 9
Keyngi misolda for siklidan uzgaruvchini boshkaradigan initsializatsiyalash kismi olib
tashlangan.
G’G’ For siklini aniklash bitta shartdan iborat.
Using System;
class Emptyl {
public static void Main( ) {
int i;
iq0; G’G’ Sikldan initsializatsiyalash bulimini olib tashlaymiz
for (; i < 10; ) {
Console. WriteLine ( “Utish № “ Q i );
iQ Q;G’G’ Siklni boshkaradigan uzgaruvchini inkrementirlaymiz} } }
bu versiyada i uzgaruvchisi for sikliga kirmasdan oldin initsializatsiyalanadi, a uning
nomlanishida emas. Kupincha dasturchilar boshkarush uzgaruvchilarni for sikli ichida
initsializatsiyalaydi. Sikldan tashkari initsializatsiyalanadi fakat boshidagi ma’no murakkab
protsess bilan almashtirilsa, va uni sikl aniklashida kuyilishi kulaysizliklarni tugdiradi.
Cheksiz sikl.
For siklining shartli ifodasini bush koldirilib, cheksiz siklini tashkil etsa buladi
( xech kachon tugamaydigan sikl). Masalan, dasturning keying fragmentida C# dasturchilarning
kupincha foydalanadigan uslubi keltirilgan.
I for(; t) G’G’ maxsus tuzilgan cheksiz sikl.
Bu sikl cheksiz ishlaydi. Dasturlashning ba’zi bir masalalariga karamasdan ( masalan, operatsion
sistemasining boshkarish protsessorlariga), va u cheksiz siklni bor bulishini talab kiladi,
kupchilik «cheksiz sikllar» - bu sikllar fakat tugatish uchun maxsus sikllar.Shu bopning oxirida
shunday tipdagi sikllarni kanaka tugatilishi keltirilgan.
( YOrdam: break instruksiyasi yordaminda).
Tanasiz sikllar
C # da for sikli bilan boglik kismi ( yoki boshka kanakadir sikl bilan boglik), bush bulishi
mumkin. Sababi bush instruksiyasi sintaksik yuborilishi mumkin “ tanosiz” sikllari kupincha
foydali buladi. Maslan keyingi dasturda “ tanosiz “ sikli foydalanilgan 1 dan 5 ygindini
xisoblashda.
G’G’ Sikl tanosi bush bulishi mumkin.
Using System;
class Empty3 {
public static void Main( ) { int i;
int sumq0;
G’G’ 1 dan 5 gacha bulgan ygindini xisoblaymiz.
for ( i q1; i
Console. WriteLine ( “yigindi teng “ Q sum );
}
}
Bu dasturdin natiyjasi anik
yigindi teng 15.
Itibor beringki, ygindi protsessin umuma sikl ichida bajaramiz. Eng kattik dikkatingizni
iteratsion ifodaga buling.
SumQ q iQ Q
Shu instruksiyaga ukshash instruksiyalar bilan almashtirmang. Ular kup tarkalgan va ason
tushinarli, agarda ularni kismlarga ajratsak. Bu instruksiya deganimiz sum uzgaruvchisiga
yigindi natiyjalarini kuyish shart va i uzgaruvchisining ma’nosini va kegin I uzgaruvchisining
ma’nnosini inkrementirlash. Shunday kilib, oldingi instruksiya si keyingidagiga ekvivialent
buladi.
Stmq sumQI;
For siklida uzgaruvchi bilan boshkarishni belgilash.
Kupincha for sikli bilan boshkaruvchi uzgaruvchisi fakat shu sikl uchun kerak, va u boshka
yerda foydalanilmaydi. Bu paytda siklning initsializatsiyalash bulimida belgilasa buladi.
Masalan, keyingi dasturda 1 dan 5 gacha bulgan ygindini kanaka xisoblasa faktorialni xam
shunka xisoblaydi. Bu yerda i boshkarish uzgaruvchisi for sikl ichida belgilangan.
G’G’ For sikli ichida boshkarish uzgaruvchisini beligilash.
Using System;
class Forvar {
public static void Main( ) {
int sumq0; int fact -1;
G’G’1 dan 5 gacha bulgan yigindini va
faktorialni xisoblaymiz.
for ( int i q1; i
sum QqI; G’G’ I fakat sikl atrofida belgili.
Fact *q;
}
lekin I uzgaruvchisi belgili emas.
Console. WriteLine ( “yigindi teng “ Q sum );
Console. WriteLine ( “faktorial teng “ Q fact );
}
for Sikli ichida uzagruvchini belgilashda shuni unutmang: uning kurinish soxasi sikl tugashidan
tugaydi. Boshkacha aytganda kurinish soxasi for sikli Bilan cheklangan. Sikldan tashkari bunday
uzgaruvchi bor bulishini yukotadi. Agarda siklni boshkaradigan uzgaruvchini dasturning yanada
kanadir tomonida foydalanmokchi bulsangiz siz uni for sikli ichida belgilamasliginiz kerak.
While siklida
While siklining kurinishi kuyidagicha buladi.
While [ shart) instrutsiya;
Bu yerda instruksiya elementida bittalik yoki instruksiya bloki tushilinadi. Sikl ishi bilan uslovie
(shart) elementi boshkaradi, va u bool tipindagi xoxlagan ifoda bulishi mumkin. Instruksiya
elementi bajariladi kachongacha shartli ifoda XAKIYKAT ma’nosiga kaytmaganuncha. Bu shart
yolgon bulganda boshkarish sikldan keyingi instruksiyaga beriladi.
Oddiy misolni karaymiz, va bunda While sikli berilgan sonning tartibin xisoblashda
foydalaniladi.
G’G’ Butun sonning tartibin xisoblash.
Using System;
class WhileDemo {
public static void Main( ) {
int num; int mag ;
num q 435679;
mag q 0;
Console. WriteLine ( “ Son “ Q num );
While (num > 0 ) {
Mag Q4- ; num q num
G’10 ;
};
Console. WriteLine ( “ tartib “ Q mag );}}
Bu dasturning natiyjasi kuidagicha
Son: 435679 Tartib: While sikli kuyidagicha ishlaydi. Num uzgaruvchisining ma’nosi
tekshiriladi, agarda u nuldan katta bulsa, mag schetchigi inkrementirlanadi, a num ma’nosi loflga
bulinadi va for sikli num ma’nosi nuldan katta bulmaganuncha takrorlanadi. Num ma’nosi nulga
teng bulgan paytda sikl tugaydi, a mag uzgaruvchisi esa shu sonning tartibin kursatadi.
For siklidak while siklida shartli ifoda siklga kirishdan oldin tekshiriladi, bu deganimiz sikl
tanosi biron marta xam bajarilmaydi. Endigi dasturda siklning bu xossasini sikl boshlanmasdan
oldin testdan utkazishni olib tashlaydi.
G’G’ 2 Sonining butun darajalarini xisoblash.
Using System;
class Power {
public static void Main( ) {
int e; int result ;
for (int iq0 ; i< 10; iQQ) {
result q1; eqI;
while (e > 0) {
result *q2;
e -;
}
Console. WriteLine ( “ darajada 2 “ Q iQ “ teng “ Qresult );
Bu dasturning natiyjasi kuidagicha
if operatori
Siz tanlagan holda dasturning biror Qismini shartli if operatori yordamida bajarishingiz mumkin.
Bu operator boshQa ixtiyoriy tildagi if operatoriga juda yaQin. Xususan, sintaksis bo’yicha S,
CQQ va Java tillaridagi if operatori bilan bir xil. Uning eng oddiy ko’rinishi Quyida
tasvirlangan:
if (shart) opera tor ;
Bu yerdagi shart—true yoki false Qiymat oluvchi mantiQiy ifoda. Agar shart rost bo’lsa
operator bajariladi, agar shart yolg’on bo’lsa unda operator tushirib Qoldiriladi. Shartli if operatorini ishlatilishiga misol keltiramiz:
if(10 < 11) Console.WriteLine("10 kichik 11 dan");
Bu holda 10 soni 11 ga Qaraganda kichik (shartli ifoda rost), natijada WriteLine () ; operatori
bajariladi.
Misol :
if(10 < 9) Console.WriteLine("Bu satr ekranga chiQarilmaydi"),1.
S# da butunsonli berilganlar tipi uchun int kalit so’zi ishlatiladi
2.
double — bu Qo’zg’aluvchi nuQtali ikkilangan aniQlikdagi berilganlar uchun
ishlatiladigan kalit so’zi.
3.
Yo’Q. Lekin bu Qulay.
Bu holda 10 raQami 9 raQamidan katta bo’lganligi sababli WriteLine O; operatoriga murojaat
Qilinmaydi. S# da shartli ifodalarda ishlatilishi mumkin bo’lgan taQQoslash operatorlari
komplekti mavjud. Quyida shu operatorlar va ularning Qiymatlari tavsiya etiladi.
Operator Tasvir
< Kichik
> Katta
>q Katta yoki teng
q q Teng
!q Teng emas
Aytib o’tamizki, teng operatori ikkita tenglik belgisidan tashkil topar ekan. Quyida if
operatorining bajarilishini ko’rsatadigan dastur tavsiya etiladi:
G’G’ Dasturda if operatorining bajarilishi namoyish etiladi.
using System;
class IfDemo {
public static void Main() { int a, b, c;
a q 2; b q 3;
if(a < b) Console.WriteLine("a o’zgaruvchining Qiymati
"Q " b o’zgaruvchining Qiymatiga Qaraganda kichik.");
G’G’ Parametr sifatida keltirilgan
G’G’ navbatdagi WriteLineO usulidagi satr ekranga chiQarilmaydi
if (a q q b) Console.WriteLine ("Bu satr ekranga chiQarilmaydi.");
if operatorining ishlatilishi.
Console.WriteLine () ;
s q a - b; G’G’ s o’zgaruvchiga -1 Qiymat o’zlashtiriladi.
Console.WriteLine("s o’zgaruvchi-1 Qiymatni saQlaydi. ");
if(s >q 0) Console.WriteLine("s o’zgaruvchining Qiymati- "Q
"manfiy bo’lmagan son.");
if(s < 0) Console.WriteLine("s o’zgaruvchining Qiymati- " Q " manfiy son.");
Console.WriteLine();
s q b - a; G’G’ s o’zgaruvchiga 1 Qiymat o’zlashtiriladi.
Console.WriteLine("s o’zgaruvchi 1 Qiymatni saQlaydi. ");
if (s >q 0) Console.WriteLine("s o’zgaruvchining Qiymati- " Q
" manfiy bo’lmagan son.");
if(s < 0) Console.WriteLine("s o’zgaruvchining Qiymati- " Q
" manfiy son.");
Bu dastur ishlaganda ekranga Quyidagi satrlar chiQadi:
a o’zgaruvchining Qiymati b o’zgaruvchining Qiymatiga Qaraganda kichik.
s o’zgaruvchi -1 Qiymatni saQlaydi.
s o’zgaruvchining Qiymati –manfiy son.
s o’zgaruvchi 1 Qiymatni saQlaydi.
s o’zgaruvchining Qiymati –manfiy son emas.
E’tibor bering, dasturning satrida bir-biridan vergul bilan ajratilgan uchta o’zgaruvchi e’lon
Qilinyapti:
int a, , s;
Aytib o’tilganidek, agar kerak bo’lsa bir xil turdagi ikki yoki undan ortiQ o’zgaruvchilar bitta
operatorda e’lon Qilinishi mumkin. Buning uchun o’zgaruvchilarning nomlarini vergul bilan
ajratish lozim.
Switch-operatori.
O’tish operatorlari.
Operator goto. break, continue operatorlari.
Sikl operatorlari. operator for, while sikli, foreach sikli.
for sikli
Siz Qandaydir kod (blok) lar ketma-ketligini bir necha marta bajarishingiz mumkin, va bunga
sikl deb aytiladi. Bu bo’limda biz for siklini ko’ramiz. S# da bu sikl xuddi S, CQQ va Java
dagiday ishlaydi. for siklining eng oddiy sintaksisi:
for(initsializatsiya, shart, iteratsiya) operator;
Siklning initsializatsiyasi javob beradigan Qismi umumiy Qabul Qilingan shaklda sikl
o’zgaruvchisiga biror boshlang’ich Qiymatni beradi. Shart sikl o’zgaruvchisini tekshiradigan
matiQiy ifoda hisoblanadi. Agar mana shu ifodaning natijaviy Qiymati true bo’lsa, sikl
bajarilishi davom etadi, agar u yolg’on bo’lsa sikl yakunlanadi. Iteratsion ifoda esa sikl
o’zgaruvchisining har bir siklning bajarilishidagi o’zgarishini ifodalaydi. for siklining ishlatilishi
Quyidagi QisQa dasturda namoyish Qilinadi :
G’G’ for siklining ishlatilishini namoyish Qilinadigan dastur.
using System;
class ForDemo {
public static void Main() { int count;
for(count q 0; count < 5; count q countQ1) {
int num q count Q1;
Console.WriteLine(" Bu siklning " Q num Q "- o’tish."); )
Console.WriteLine("Sikl tugadi.");
Quyida bu dasturning bajarilish natijasi ko’rsatilgan:
Bu siklning 1- o’tishi.
Bu siklning 2- o’tishi.
Bu siklning 3- o’tishi.
Bu siklning 4- o’tishi.
Bu siklning 5- o’tishi.
Sikl tugadi.");
Bu misolda count sikl o’zgaruvchisi bo’lib hisoblanadi. Dastlab for siklining initsializatsiyasida
unga nol Qiymat beriladi. Siklning har bir takrorlanish boshida (birinchisi ham kiradi) count < 5
shartini tekshirish bajariladi. Agar shart rost bo’lsa, u holda writeLir.e() operatori bajariladi,
so’ngra siklning iteratsion Qismi a zatem initsializatsiya Qilinadi (ya’ni count o’zgaruvchisiga
yangi count Q i ga teng bo’lgan Qiymat beriladi). Bu jarayon toki sikl o’zgaruvchisining Qiymati
shartni Qanoatlantirmaguncha takrorlanaveradi. Shu paytdan boshlab siklning bajarilishi
to’xtatiladi. Dasturdagi nun o’zgaruvchisi chiQarilayotgan satrlarning sikl bo’yicha o’tishlari
raQami noldanmas, birdan boshlanishi uchun kiritilgan.
Amalda professional tarzda yozilgan S# dasturda siz oldingi misolda yozilganidek siklning
iteratsion Qismini uchratmaysiz. YA’ni, Quyida keltirilganiga o’xshash for siklida juda kam
uchraydi.
count q count Q 1;
Sababi shundaki, S# da, o’zgaruvchining dastlabki Qiymatini birga ancha samarali oshiradigan
maxsus inkrement degan operator bor. Bu operator ikkita Qo’shish belgisi (QQ) bilan
belgilanadigan operatordir. YUQorida keltirilgan for siklining iteratsion Qismi inkrement
operatori yordamida Quyidagicha yoziladi:
countQQ;
Shunga ko’ra for siklining to’liQ ko’rinishi Quyidagicha bo’ladi:
for(count q 0; count < 5; countQQ)
U xuddi oldingidek aniQ ishlaydi. Shuning bilan bir Qatorda S# da ikkita minus belgisi (--) bilan
ishlatiladigan dekrement operatori ham bor. Bu operator o’z operandini bittaga kamaytirish
uchun ishlatiladi.
Bir daQiQalik amaliyot.
1.
if operatori Qanday aytiladi ?
2.
for operatori Qaysi operatorlarga kiradi?
3.
S#da Qanday taQQoslash operatorlari bor?
Kod bloklaridan foydalanish
S# tilining yana bir kalit elementlaridan biri kod bloki bo’lib hisoblanadi. Kod bloki deb, ikki
yoki bir necha operatorlarning figurali Qavslarga olib yozilishiga aytiladi. Kod blokini hosil
Qilgach, u mantiQiy elementga aylanadi, va uni bitta operator singari ishlatish mumkin bo’ladi.
Blok - if va for operatorlarida ishlatilishi mumkin. Quyidagi kod fragmentini ko’ramiz:
if (w < h) (
v - w * h; w -q 0; }
1.
if — bu shartli operator.
2.
for kaliti sikl operatoriga tegishli.
3.
S# da Quyidagi taQQoslash operatorlari mavjud: , >q, qq, ■ q.
Agar bu if operatorida w ning Qiymati h o’zgaruvchining Qiymatiga nisbatan kichik bo’lsa, u
holda blok ichidagi har ikkala operator ham bajariladi. YA’ni modomiki operator tubi blok
ichida mantiQiy birni shakllantirar ekan, bitta operator boshQasi bajarilmasdan turib
bajarilmaydi. Bu shuni ko’rsatadiki, agar sizga ikkita operator orasida mantiQiy bog’liQlik kerak
bo’lsa , siz ularni blokka olishingiz kerak bo’ladi. Kod bloklari ko’pgina algoritmlarni tushunarli
va yuQori samaradorlik bilan bajarishlariga imkon beradi. Quyidagi dasturda kod blokidan
foydalanib nolga bo’lish imkonlarini yo’Qotish tasvirlangan:
G’G’ Dasturda kod blokidan foydalanish namoyish Qilinadi
using System;
class BlockDerao (
public static void Main() ( int l, j, d;
i q 5; j - 10;
G’G’ Bu kod bloki if operatoriga tegishli ".
if(i !q 0) (
Console.WriteLine("i o’zgaruvchining Qiymati nolga teng emas.");
d q j G’ i;
Console.WriteLine(" jG’i teng " Q d);
Professional javoblari
Savol. Kod blokidan foydalanish dasturning samaradorligiga ta’sir Qiladimi (ya’ni uning
bajarilish vaQti oshib ketmaydimi)?
Javob. Kod blokidan foydalanish dasturning bajarilish vaQtini oshirmaydi. Modomiki ular
ma’lum bir algoritmlarning kodlanishini soddalashtirar ekan, ularning ishlatilishi Qoida bo’yicha
dasturning bajarilish tezligini va uning samaradorligini oshiradi.
Bu dasturning bajarilish natijasi Quyida keltirilgan :
i o’zgaruvchining Qiymati nolga teng emas. jG’i teng 2
Dasturdagi if operatoriga bitta operator emas, balki kod bloki to’g’ri keladi. Agar if operatori
bilan boshQariladigan shart rost bo’lsa (xuddi hozirgi holatdagidek), unda blokdagi barcha uchta
operator ham bajariladi. i o’zgaruvchiga 0 Qiymatni berib, natijaning Qanday bo’lishini ko’ring.
Keyinchalik kod bloklarining Qo’shimcha xossalari va Qo’llash usullari borligini ko’rish bilan
birga, ularning asosiy vazifasi mantiQiy bo’linmaydigan kod birligini tuzishdan iboratdir
NuQta vergul belgisi va pozitsiyalashtirish
S# da simvol nuQta vergul belgisi operatorning tamom bo’lganligini ifodalaydi. YA’ni har bir
alohida operator nuQta vergul belgisi bilan tugallanishi lozim. Ma’lumki, blok mantiQan bog’liQ
bo’lgan figurali Qavs ichiga olingan operatorlarning dastasi bo’lib hisoblanadi, shuning uchun
uni nuQta vergul belgisi emas, balki yopiladigan figurali Qavs yakunlaydi.
S# satrning tugashini operatorning tugallanishi deb aniQlamaydi, faQat nuQta vergul belgisigina
operatorni tugallashi mumkin. Shu sababli nuQta vergulni satrning Qaeriga joylashtirishning
farQi yo’Q. Masalan, S# satrlari uchun x q u;
u q u Q 1;
Console.WriteLine(x Q " " * u);
kodi Quyidagi
x q u; u q u Q 1; Console.WriteLine(x Q " " Q u);
satr bilan bir xil ma’noga ega bo’ladi. Bundan tashQari, operatorning alohida elementlari ham
har xil satrlarda joylashishi mumkin. Masalan, Quyidagi joylashish o’rinli:
Console.WriteLine("Bu satr chiQarishda ancha ko’p joyni g’p" Q "egallaydi, chunki u
berilganlardan tashQari '' Q x Q y Q z Q "g’p yana uchta satrli literlardan ham tashkil topgan.");
Bunday uzun satrlarni bo’lish usuli dasturni o’Qilishini yaxshilash uchun ishlatiladi. Shuning
bilan birga bu satr chiQrilganda Qanday ko’rinishga ega bo’lishini ko’rish mumkin.
Chekinishlardan foydalanish
Siz ehtimol payQagan bo’lsangiz kerak, oldingi misollarda ba’zi bir operatorlar chekinishlar
bilan yozilgan edi. S# tili kodni kiritishda (operatorlarni kiritishda) har xil chekinishlarning
Qo’llanilishi, yoki ularning Qo’llanilmasligi dasturning ishlash Qobiliyatiga ta’sir ko’rsatmaydi.
Ammo dastur yozishning umumiy Qabul Qilingan ko’rinishi mavjud ekan, Qaysiki bu kitob ham
unga amal Qiladi, sizga ham unga rioya Qilishingizni maslahat beramiz. Buning uchun kodni
kiritishda har bir ochilgan Qavsdan so’ng chekinish Qilish kerak (yuQoridagi satr boshiga
nisbatan 2-3 ta probel) va aksincha har bir yopilgan Qavsdan so’ng orQaga Qaytish kerak.
Qo’shimcha chekinish ko’zda tutilgan operatorlar bundan mustasno bo’lib, ular keyinroQ sanab
o’tiladi.
Bir daQiQalik amaliyot.
1.
Kod blokini Qanday tuzish kerak?
2.
S#da operatorlar Qanday yakunlanadi?
1.
S#da barcha operatorlar bitta satrda boshlanishi va tugallanishi kerak degan tasdiQ
to’g’rimi?
1.
Operatorlar ketma-ketligi ochilgan ({) va yopilgan (}) figurali Qavslar ichiga
joylashtiriladi. Blok mantiQan kod birligini tashkil Qiladi.
2.
S# da operatorlar nuQta vergul belgisi bilan tugallanadi.
3.
Yo’Q.
2-Qism.
Operatorlar va Qiymatlar tipi.

S# Qiymatlar tipi bazasi

Literallar va ulardan foydalanish

Tuzilgan o’zgarishlarni aniQlash

O’zgaruvchilarni ko’rish Qismi

Arifmetik operatorlar

Logik va taQQoslangan operatorlar

O’zlashtirish operatorlari

Nusxa keltirish operatsiyasi va aniQ va aniQmas Qiymatlar tipini o’zgartirish.

S# ni ifoda Qilish
Ma’lumotlar tipi va operatorlar xar kanday dasturlash tillarining asosini tashkil kiladi. Bu
elementlar dasturlash tilining imkoniyatlarini va ishlatilishi mumkin bulgan masalalar darajasini
belgilab beradi. S# juda kup ma’lumotlar tipi va operatorlarni kabul kiladi, bu esa uni kupchilik
dasturlash masalalarini yechishga kulay kiladi. Ma’lumotlar tipii va operatorlarni kurib chikish
uchun juda kup vakt talab kilinadi. Bu bobda biz asosiy ma’lumotlar tipi va nisbatan kuprok
ishlatiladigan operatorlar xakida, shuningdek uzgaruvchilar va vo’rajeniyalar xakida batafsil
ma’lumot beramiz.
S# Ma’lumotlar tipilari ustidan kat’iy nazorat
S# - ma’lumotlar ustidan kat’iy nazorat urnatilgan dasturlash tili. Bu S# dagi barcha amallar
ma’lumotlar tipining mosligiga kompilyator tomonidan nazorat kilinishini bildiradi. Agar
amallar mosligi bajarilmasa, ular kompilyatsiya kilinmaydi. Bunday ma’lumotlar tipi ustidan
kat’iy nazorat xatolarni oldini olishga yordam beradi. Nazoratni amalga oshirish uchun barcha
uzgaruvchilarga, xisob natijalariga va kiymatlarga anik bir tip beriladi(YA’ni anik tipga ega
bulmagan uzgaruvchi mavjud emas). Kiymat tipi uning ustidan bajarilishi mumkin bulgan
amallarni aniklab beradi. Bir ma’lumotlar tipi uchun ruxsat etilgan amallar, boshkasi uchun
takaklangan bulishi mumkin.
Ma’lumotlarning oddiy tipi
S# kiritiladigan ma’lumotlar tipining ikki turini uz ichiga oladi oddiy(yoki soda) va murojat
etuvchi tiplar. Murojat etuvchi tiplar sinfi xakida biz keyinchalik tuxtalib utumiz. S# yadrosiga
kiruvchi un uch oddiy tip 2.1 jadvalida kursatilgan
Tip
Tavsifi
Bool
Kiymatlari TrueG’False (xakikatG’yolgon)
Byte
8 bitli belgisiz butun son
Char
Belgi
Decimal
Iktisodiy xisoblashlar uchun sonli tip
Double
SuzuvchiG’kuchuvchi(S plavayuhey tochkoy)
nuktali ikkilangan aniklikdagi son
Float
SuzuvchiG’kuchuvchi(S plavayuhey tochkoy)
nuktali birlamchi aniklikdagi son
Int
Butun son
Long
Uzun son
Sbyte
8 bitli belgili butun son
Short
Kiska butun son
Uint
Belgisiz butun son
Ulong
Belgisiz uzun butun son
Ushort
Belgisiz kiska butun son
S# da xar bir ma’lumotlar tipi uchun kiymatlar diapazoni va ular ustidan bajarilishi mumkin
bulgan amallar katiy muvofiklikda belgilangan. Shunga muvofik kuchish talablari bu
muvofikliklarning bajarilishini katiy nazorat kiladi. Masalan, int tipi dasturning ixtiyoriy
bajarilish muxiti uchun bir xil, shuning uchun xar bir platformaga muvofiklashtirish uchun kodni
boshkatdan yozishning xojati yuk. Katiy muvofiklashtirish kuchishni amalga oshirish uchun
kerak, ammo bazi platformalarda uncha katta bulmagan ishlab chikarishdagi yukotishga olib
kelishi mumkin.
Butun sonlar tipi
S# da tukkiz turdagi butun sonlar tipi belgilangan: char, byte, sbyte, short, ushort, int, uint, long
va ulong. Char tipi asosan belgilar takdimoti uchun ishlatiladi, va shu bobda keyincha
tavsiflanadi. Kolgan sakkiz tip sonlar ustidan amallar bajarish uchun ishlatiladi. Kuyidagi
jadvalda ushbu sakkiz tipga mvofik ajratiladigan xotira xajmi va yul guyiladigan kiymatlar
diapazoni kursatilgan.
Tip nomi
Bitlar soni
Kiymatlar chegarasi
Byte
8
0 dan 255 gacha
Sbyte
8
-128 dan 127 gacha
Short
16
-32768 dan 32767 gacha
Ushort
16
0 dan 65535 gacha
Int
32
- 2147483648 dan 2147483647 gacha
Uint
32
0 dan 4294967295
Long
64
-9223372036854775808 dan
9223372036854775808 gacha
Ulong
64
0 dan 18446774073709551615 gacha
Jadvaldan kurinib turibdiki S# da xam belgili, xam belgisiz butun sonlar varianti kursatilgan.
Ular orasidagi fark butun sonning yukori bitini interpritatsiya kilish uslubida. Belgili butun son
kursatilganda butun sonning yukori bitni belgi bayrogi sifatida interpritatsiyasi kuzda tutilgan
kodni generatsiya kiladi. Agar bayrok 0 belgili bulsa, bu musbat son, agar 1 bulsa, bu manfiy
son. Manfiy sonlar deyarli xar doim ikkilangan tuldirish metodini ishlatish bilan kursatiladi. Bu
metodda sonning barcha bitlari(belgi bayrogidan tashkari) invertlanadi, sung bu songa bir
kushiladi, eng sungida belgi bayrogiga 1 kiymati beriladi.
Belgili butun sonlar kupgina algartmlar uchun juda muxim, lekin ular mos belgisiz butun
sonlarning absolyut kismining fakat yarmigagina ega. Masalan, short 32767 tipidagi soni ikkilik
sanok tizimi kurinishida yozaylik: 01111111 11111111
Bu belgili tip bulgani uchun yukori bitga 1 kiymati berilganda -1(agar ikkilangan tuldirish
usulidan foydalanilsa) sifatida interpritatsiya kilinadi. Ammo uni ushort tipida e’lon kilinsa, unda
yukori bitga 1 kiymati berilganda son 65535 sifatida interpritatsiya kilinadi.
Eng kup ishlatiladigan butunsonli tip – bu int. Int tipi uzgaruvchilarini sikllarni boshkarish,
massivlarni indeksatsiyasida va turli matematik xisoblashlarda ishlatiladi. S# da Int tipidagi
sonlardan katta sonlar unit, long, ulong tiplarida, belgisiz butun sonlar bilan ishlaganda esa unit
tipi ishlatiladi.
Belgili katta kiymatlar uchun long tipi, undan xam katta musbat sonlar (belgisiz butun sonlar)
uchun – ulong tipi ishlatiladi.
Kuyida tomoni uzunligi 1 milga teng bulgan kub xajmini xisoblash(dyuymlarda) dasturi
kursatilgan. Bu kiymat yetarli darajada katta bulgani uchun uning saklanishga dastur long tipi
uzgaruvchisini ishlatadi.
G’*
dastur tomoni uzunligi 1 milga teng bulgan kub xajmini xisoblaydi(dyuymlarda)
(ma’lumot uchun: 1 milda – 5280 fut, 1 futda – 2 dyuym bor)
*G’
Using system;
class inches {
public static void Main {}{
Long ci;
Long im;
im q 5280*12;
ci q im*im*im;
Console. WriteLine(“tomoni uzunligi 1 milga teng bulgan kub xajmi” Q ci Q “ga teng.”);
}
}
Kuyida bu dastur natijalari kursatilgan.
tomoni uzunligi 1 milga teng bulgan kub xajmi 254358061056000ga teng.
Bunday natija int yoki uint tipidagi uzgaruvchiga sigmasligi anik kurinib turibdi.
byte va sbyte – eng kichik butun sonlar tipi. byte tipi kiymati 0 dan 255 gacha bulgan oralikda
joylashishi mumkin. Byte tipi uzgaruvchilari biror tuzilmada generatsiya kilingan malumotning
baytlar okimi kabi kayta ishlanmagan ikkilangan ma’lumotlar bilan ishlashda juda kul keladi.
Uncha katta bulmagan belgili butun uzgaruvilarida sbyte tipi ishlatiladi. Kuyida kursatilgan
dasturda 1dan 100 gacha bulgan barcha butun sonlarning yigindisi xisoblanayotgan for siklini
nazorat kilish uchun byte tipi uzgaruvchisi ishlatiladi.
G’G’ byte tipining ishlatilishi
Using system;
class Use_byte {
public static void Main {}{
byte x;
int sum;
sum q 0;
for(x q 1; x 1);
sum – sum Qx;
Console. WriteLine(“1dan 100gacha bulgan butun sonlar yigindisi” Q sum);
}
}
Bu dasturning natijasi kuyidagicha:
1dan 100gacha bulgan butun sonlar yigindisi 5050
Ushbu dasturda for siklini nazorat kilish uchun byte tipi kiymatlar oraligiga kiruvchi 1dan
100gacha bulgan sonlar ishlatilgani sababli kattarok sonlar bilan ishlash imkonini beruvchi
boshka tiplarni belgilashga xojat yuk. Uzgaruvchiga tugri tipni belgilash va tizim zaxirasin tejash
maksadida yukorida keltirilgan jadvaldan foydalaning va uzgaruvchi kiymati kanoatlantiradigan
tiplarning oraligini tanlang.
Suzib yuruvchi nuktali ma’lumotlar tipi
1 bobda aytilganidek suzib yuruvchi nuktali ma’lumotlar tipida kasr kismi mavjud bulgan sonlar
kursatiladi. S# da suzib yuruvchi nuktali ikki tip mavjud, float va double, mos ravishda birlamchi
va ikkilangan aniklikdagi sonlarni kursatadi. float tipiga 1.5E-45 dan 3.4EQ38 gacha bulgan 32
bit ajratiladi. double tipiga ishlatilishi mumkin bulgan sonlar oraligini 5E-324 dan 1.7EQ308
gacha kengaytiruvchi 64 bit ajratiladi. Kuprok double tipi ishlatiladi. Buning sabablaridan biri S#
kutubxonasidagi matematik funksiyalar double tipiga ega bulgan kiymatlarning ishlatishidir.
Masalan System. Math. standart sinfida aniklangan Sqrt() usuli double kiymatli argumentni
uning kvadrat ildizini xam double kiymatiga kaytaradi. Kuyida misol tarikasida ikki katet
uzunligi bilan berilgan gipotinuza uzunligini xisoblash uchun Sqrt() usuli kullangan.
G’* Dasturda gipotenuza uzunligini ikki katet uzunligi orkali topish imkonini
beruvchi Pifagor teoremasidan foydalanilgan
*G’
Using system;
class Hypot {
public static void Main {}{
double x, y, z;
Sqrt() усулининг чакирилишига этибор беринг. Усул номи у тегишли булган номдан нукта
билан ажратилган.
xq3;
yq4;
zqMath.Sqrt(x*xQy*y)
Console. WriteLine(“Gipotinuza uzunligi ” Q z);
}
}
YUkoridagi dastur natijasi :
Gipotinuza uzunligi 5
Bu dasturning yana bir tomonini aytib utish kerak. YUkorida aytilganidek Sqrt() usuli Math.
Sinfiga mansub. Usul nomi u tegishli bulgan nomdan nukta bilan ajratilganligiga etibor bering.
Bu kabi yozuvni WriteLine() usulidan oldin Console sinfining nukta bilan ajratilganda kurgan
edik. Barcha usullarni xam oldin ular tegishli bulgan sinf nomini kursatgan xolda chakirilishi
shiart emas, lekin bazilariga aynan shunday murojat kilish shart.
Decimal tipi
S# ning eng kizikarli sonli tipi pul xisob-kitobida ishlatiladigan decimal tipi bulsa kerak.
Decimal tipida 1E-28 dan 7.9EQ28 gacha bulgan oralikdagi kiymatlarga 128 bit ajratiladi. Suzib
yuruvchi nutali sonlar ustidan arifmetik xisoblash olib borilganda kiymatlarni birnecha marta
yaxlitlash uncha anik bulmagan natijani beradi. Decimal tipi yaxlitlashdagi xatoliklarni
tugirlaydi, va sonlarni unning 28 darajasi aniklikda kursatadi. Unlik xonalarni yaxlitlashda
bexato kursatish imkoniyati ayniksa iktisodiy xisoblashlarda kul keladi.
Misol tarikasida pul xisob-kitobida decimal tipidan foydalangan dasturni kurib chikamiz. Dastur
foizlar utkazilganidan sung balans xisobini oladi.
Mutaxassis javoblari!
Savol: Oldinlari kupkina tillar bilan ishlaganman, lekin xech kaysi birida Decimal tipini
uchratmaganman. Bu tip fakat S# ga xosmi?
Javob: Xa, bu tip fakat S#ga xos bulib SQQ,S yoki Java tillarida mavjud emas.
Shu urinda Decimal tipidagi uzgarmaslardan sung m yoki M kushimcha tarzda yozilishi kerak.
Aks xolda ular Decimal tipiga tugri kelmaydigan suzib yuruvchi nuktali uzgarmaslar deb kabul
kilinadi.
Belgilar
Boshka dasturlash tillaridan farkli ravishda (SQQ kabi, belgilarni e’lon kilishda 8 bit ajratiladi,
bu esa 255 belgi bilan ishlash imkonini beradi.) S# da butun Dunyu tillarida ishlatiladigan
belgilar tuplami kiritilgan Unicode belgilarning standart majmui ishlatiladi. S# da char- 16 bit
ajratiladigan belgisiz tip, bu esa 0 dan 65535 gacha bulgan oralikdagi kiymatlar bilan ishlash
imkonini beradi(ya’ni, 65535 belgi bilan ishlash). 8 bitli ASCII belgilar majmui Unicode ning
tarkibini tashkil kiladi va 0 dan 127 gacha bulgan oralikda joylashgan. Shunday kilib ASCII
belgilari Unicode da xam saklanib kolgan.
Belgili kiymatni uzgaruvchiga uzlashtirish uchun uzlashtirish operatoridan ungda turgan belgini
bittalik kushtirnok ichiga olish kerak. Kuyida ch uzgaruvchiga x kiymat uzlashtirish
bajariladigan operatorlar sintaksisi berilgan.
Char ch;
Ch q ‘x’;
Elgili kiymatni chikarish uchun Console.WriteLine() operatoridan foydalaniladi. Keyingi kator
ch uzgaruvchining kiymatini chikaradi.
Console.WriteLine(“ch uzgaruvchining kiymati - ” Q ch);
Butun sonli tipdan shar ga avtmatik ravishda utish mvjud bulmagani uchun, S#da butunsonli tip
deb aniklangan shar tipi sonlarni e’lon kilish uchun ishlatiladigan boshka butunsonli tiplar bilan
uzaro moslashmaydi.
Masalan, kodning keyingi kismi bajarilmaydi:
Char ch;
Ch q 10;G’G’ kod kismi xato yozilgan
Buning sababi 10 butun son va Char tipiga avtomatik ravishda utkazilmaydi. Shundan kelib
chikadiki, ushbu jarayonda tiplar uzaro moslashmaydi. Ushbu kodni kompilyatsiya kilganda
kompilyator xato deb kursatadi.
Keyinchalik shu bobda bu cheklovni kanday xal kilishni kurib utamiz.
Mutaxassis javoblari!
Savol: Nima uchun S# da Unicode dan foydalaniladi?
Javob: S# ni yaratishda ishlab chikaruvchilar uz oldiga butun dunyoda ishlatilishi mumkin
bulgan kompyuter tilini yaratishni maksad kilib kuygan. Shuning uchun ishlab chikaruvchilar
dunyoning barcha tillari kiritilgan belgilarning standart majmuasi Unicode dan foydalanishgan.
Tugri bu tilning ishlatilishi belgilari 8bitda kursatilishi mumkin bulgan ingliz, fransuz, olmon
yoki ispan tillarida ishlatilishi uncha samarali emas, lekin bu dasturlarning global mikyosda
utishi uchun tulanadigan xak.
Bul tipi
S#da bool – bul tipi uchun ikki kiymat aniklangan true va false (rost va yolgon)
Demak bool tipidagi uzgaruvchi yoki mantikiy masala bu ikki kiymatdan biriga teng buladi.
Bundan tashkari bool tipi kiymatlarini butunsonli tipga utkazishning imkoni yuk. Masalan 1
kiymati true yoki 0 kiymati false tarzida shakllana olmaydi.
Bool tipi ishlatilishi kursatilgan dastur namunasini keltiramiz:
G’G’ dastur bool tipi ishlatilishini kursatad
Kuyida ushbu dastur natijasi keltirilgan
b uzgaruvchisining kiymati false
b uzgaruvchisining kiymati true
(10>9) bu true
Bul uzgaruchisining bazi bir xususiyatlariga etibor bering. Birinchidan, bool uzgaruvchisi
WriteLine() orkali chikarilganda ekranda true yoki false suzlari chikarilmokda. Ikkinchidan, bool
uzgaruvisini ishlatish bilan if operatorini boshkarish mumkin. Agar if operatori bajarilish sharti
rostlik bulsa, unda if operatorini kuyidagicha yozish shart emas:
if(b – true)
Kiskarok yozish xam mumkin
if (b)
Uchinchidan < kabi takkoslash operatorlari natijasi bool tipi kiymatiga ega buladi. Shuning
uchun xam 10>9 takkoslanishda ekranga true chikarilmokda. 10>9 yozilgan kushimcha kavuslar
juftligi Q operatorining > operatoridan muximrok bulgani uchun kuyilgan.
Minutli amaliyot!
1.
Unicode nima?
2.
bool tipi uzgaruvchisi kanday kiymatlarga ega bula oladi?
3.
Char tipi ma’lumotlarining bitlardagi ulchovi kancha?
Chikarishlarni formatlash.
Ma’lumotlarning keyingi tipini kurib chikishdan oldin kichik tuxtash kilamiz. Shu paytgacha biz
chikarilayotgan ma’lumotlar ruyxati kismlarini Q belgisi bilan aeratib kelardik:
Console. WriteLine(“Gipotinuza uzunligi ” Q z);
Bu kulay, lekin sonli ma’lumotlarni chikarishning bunday usuli ma’lumotlarning ekranda paydo
bulishini nazorat kilishga imkon bermaydi. Masalan, suzuvchi nuktali kiymatlar unlik
darajalarini nazorat kilish imkonini bermaydi. Keyingi operatorni kurip chikaylik:
Console. WriteLine(“10G’3 ” Q100G’30);
Mars bilan suhbat
Mars bilan yer orasidagi masofa kamida 34 mlion mil. Biz bilan so’zlashish uchun marsga inson
joulashtiramiz, maQsad shu masofada so’zlashish uchun Qancha vaQt ketishini bilish dasturini
tuzish.yorug’lik tezligi 186000 milG’sek , tqsG’v signalni Qancha vaQtda yetib kelishini
aniQlash uchun masofani yorug’lik tezligiga nisbatini olish kerak. VaQt birligi sekund va
minutlarda hisoblanadi.
Qadamli Qo’llanma
1.
yangi fayl tuzing va nomlang.Vfrs. cs.
2.
vaQt xabarini Qancha vaQtda kelishini aniQlang
double distance;
double lightspeed;
double delay;
double delay in min;
3.
boshlang’ich o’zgaruvchi Qiymatini distance ba lightspeed bering
distance q 34000000; G’G’34000000mil
lightspeed q 186000; G’G’186000milG’sek
4.
xabarning Qancha vaQtda kelganini bilish uchun distanceG’1-ghtspeed ni olish kerak.
Delay q distance G’ lightspeed;
Console. Writelene (Er bilan Mars orasidagi masofa n” Q delayQ “ sekund)
5.
Agar natija minutlarda olingan bo’lsa sekundga aylantiring, Quyidagi kod orQali natijani
ekranga chiQaring
Delay_in_min q delayG’60;
Console. Writelene (“Qdelay_in_min ”);
Quyida Mars.cs. dasturining to’liQ Qismi keltirilgan
G’*
Using System;
Class Mfrs {
Public static void Main ( ) {
Double distance;
Double lightspeed;
Double delay;
Double delay_in_min;
distance q 34000000; G’G’34000000 mil
lightspeed q 186000; G’G’186000 milG’sek
Delay q distance G’ lightspeed;
Console. Writelene (Er bilan Mars orasidagi masofa n” Q delayQ “ sekund)
Delay_in_min q delayG’60;
Console. Writelene (“Qdelay_in_min ”);
}
}
65-bet.
6-7-8 noaniQ o’Qib bo’lmadi.
66-bet
16-birliklar
Ba’zi dasturlarda o’nlik sanoQ tizimining o’rnida o’n oltilik tizimi, ya’ni 0 dan 9 va A da F
gacha raQamlarni foydalanish Qulaydir. Bunda F va F gacha harfiy belgilaga mos ravishda 10
dan 15 gacha sonli Qiymat Qabul Qiladi. M: o’n oltilikdagi 10 soni o’nlikda 16 ga teng bo’ladi.
O’n oltilik sonlarning ko’p ishlatilishini hisobga olgan holda, S# da o’n oltilik sonlarni ustun
sonli formasida ishlaydi. O’n oltilik literallari OX velgisidan boshlanishi lozim.
Misollarda ko’gib chiQamiz.
Count – 0xFF; G’G’ 255 O’nlik sanoQ tizimida
Incr – 0xla; G’G’ 26 O’nlikda.
Belgili escape – ketma-ketliklar
S# dagi ko’pchilik kiritiluvchi usuldagi o’zgaruvchilar Qavs ichiga olinadi.
Ammo ayrim belgilarni Qo’llashda muammoli bo’ladi. Bundan tashQari belgi Qismi S# da
maxsus Qiymatli bo’ladi. Qruning uchun ularni to’g’ridan- to’g’ri ishlatib bo’lmaydi. Ana
shunday sabablarga ko’ra S# da shunday muammolarni hal Qilish uchun 2.2 jadvalda keltirilgan
escape – ketma – ketliklar ishlatiladi. Bu ketma-ketliklar ajratilgan belgilar o’rnida Qo’llaniladi.
M: tabulyatsiya belgisi Quyidagi o’zgaruvchilar yordamida o’zlashtiriladi.
Ch-‘g’t’;
Shu urda Ch- o’zgaruvchisi -‘g’t’ , birlik Qo’shtirnoQ ichiga olinadi.
2.1 jadavl. escape – ketma-ketliklar
g’a ogohlantirish (Qo’ng’iroQ)
g’b bir o’ringa Qaytish (backspace)
g’t yangi sahifaga o’tish (formfeed)
g’n yangi Qatorga o’tish(linefeed)
g’r karetkani Qaytarish(enter)
g’t gorizontal tabulyatsiya
g’v vertikal tabulyatsiya
g’0 nol
g’’ birlik Qo’shtirnoQ
g’” ikkilik Qo’shtirnoQ
g’g’ teskari QiyshiQ chiziQ
Matnli literallar
S# da yana bir turli literallar- integrali, ya’ni ikkili Qo’shtirnoQ olinadi. Quyuda ularga misollar
keltiramiz;
“kichik tekshiruv matn”
Siz bundau ko’rinishdagi satrli (matinli) WriteLine ( ) byrug’ida ko’rib chiQQansiz.
Bundan tashQari matnli literallar bir va birnecha escape – ketma-ketliklardan iborat bo’lishi
mumkin.
Using System;
Class StrDemo
Public stat_c vo_d Na n ( )
Console WriteLine (Birinchi Qator , Ikkinchi Qator)
Console WriteLine (“Ag’Bg’C”);
Console WriteLine (“Dg’Eg’U”);
}
}
Ushbu dastur Quyidagi matn satrlarni chiQaradi.
Birinchi Qator
Ikkinchi Qator
AVS
D ye U
O’zgaruvchilar va ularni aniQlash
O’zgaruvchilar Quyidagi operatorlarda tavsiflanadi: type, var
type - o’zgaruvchining turi (tipi)
var -har Qanday haQiQiy sonli o’zgaruvchituri.
o’zgaruvchilar yordamida imkoniyatga mos keluvchi o’zgaruvchilar tipi yaratiladi.
S# dagi varcha o’zgaruvchilar ularning Qo’llashdan oldin yaratilib olinishi lozim. Bizga esa
kompyurerga o’zgaruvchilar Qanday imkoniyatli va Qanday Qiymatlar Qabul Qilinishini
oldindan ko’rsatish kerak bo’ladi.
S# da bir necha har xil tipli o’zgaruvchilar mavjud.
O’zgaruvchilarni aniQlab olish (aniQlashtirish).
O’zgaruvchilarni ishlatishdan oldin ularni dasturdagi o’rnini aniQlashtirib olish lozim bo’ladi.
Dinamik aniQlashtirish
S# da dinamik o’zgaruvchan har - Qanday ifodalarni aniQlashtirish mumkin.
M: silindr hajmini berilgan radius va balandligi asosida topish dasturini kiritilgan:
g’g’ demonstratsiya Qilish dasturi
g’g’dinamik o’zgaruvchilarni aniQlashtirish
Us_ng Syster;
Class Dynlnit
Public stalic voia Marn ( )
Doudlic radius -4 , height – 5;
g’g’ dinamik o’zgaruvchining aniQlashtirish volure double vo_ume – 3.14.16. rad_us * he_qha;
Console. Writeline (silindr hajmi “-volumel”);
Ushbu dasturda uchta lokal o’zgaruvchi – radius, height va volumel Qatnashadi.birinchi ikkitasi
ani topshiriQlar, silindir hajmi Qatnashgan o’zgaruvchi dinamik aniQlashtiriladi.
O’zgaruvchili vaQt hayoti va ko’ginish Qismi
Shu vaQtgacha biz ko’rgan hamma o’zgaruvchi metodi bilan berilgan. Lekin S# da o’zgaruvchili
lokal va ichki blokni aniQlash mumkin.
1-bo’limdagi blok figunali Qavslar ichida keltirilgan. U berilgan blokning Qism blogidagi elon
Qilingan o’zgaruvchilarumumiy ko’rinishini ifodalaydi.
S# da aniQlanayotgan maydon parametrlari maydon tarkivida o’z ifodasini topgan. Kuzatish
natijasida o’zgaruvchilardan foydalanish malum miQdorda himoyalangan.
AniQlanayotgan maydon bo’ysinuvchi bo’lishi mumkin. YAngi yaratilayotgan blok Qism
bloklarni o’z ichiga oladi. Bu shuni ifodalaydiki tashg’i blok ichki bloklar xususiyati bilan
o’xshash bo’ladi.
Bu tushunchalar Quyidagi dasturda o’z aksini topgan.
using System
clfss ScopeDeno
public static vold Main ( )
int x, G’G’ x o’zgaruvchili kod
G’G’ Main ( )da Qilinga metod
X, LC
If(x-10), G’G’ yangi tuzilgan blok
Nt (y -20) G’G’ ramkali o’zgaruvchi blok
Conso e Woirtelino ( QxQ Qy)
X y 2,
Consoio WoirLane
}
}
Ko’rsatmalarda ifodalanishicha, o’zgaruvchilar if blogida e’lon Qilingan. U-100 ning o’z blokida
xotolik berishi ko’rsatmada keltirilgan. Agar ko’rsatma o’chirilsa kampulyatsiya vaQtida xatolik
yuz beradi. If blokida foydalanilgan o’zgaruvchilar ichki aniQlanayotgan maydondan tashQi
maydonga foydalanish uchun imkoniyati belgilanishi zarur. AniQlanayotgan maydondan olingan
o’zgaruvchilar berilgan maydonda mavjudligiga etibor berish kerak.
O’zgaruvchi maydondan chiQayotganda Qiymatni saQlayotganini anglatadi.
Shuningdek o’zgaruvchi blokdan chiQayotganda avvalgi Qiymatni yo’Qotadi. O’zgaruvchi
navbatdagi blokka kirayotganda Qiymatni o’zgartirilganligini ko’rishi mumkin, Quyidagi
dasturda o’z aksini topgan.
Using System:
Class VarInitDemo {
Public static void Main () {
int x:
for (x-0: x
int yq-1; G’G’ o’zgaruvchi blokka kirishdan lodin har safar o’zgartiriladi.
Consoie. Writeline (o’zgaruvchining Qiymati “ Q u teng bo’ladi)
G’G’ hamma vaQt -1 Qiymat kiradi.
U – 100;
Console.WriteLine (o’zgaruvchining Qiymati “ Qu ga teng);
}
}
}
Quyida ushbu dasturning bajarilishi ko’rsatilgan:
O’zgaruvchining Qiymati : 1 teng
Endi o’zgaruvchining Qiymati : 100 ga teng
O’zgaruvchining Qiymati : -1 teng
Endi o’zgaruvchining Qiymati : 100 ga teng
O’zgaruvchining Qiymati : 1 teng
Endi o’zgaruvchining Qiymati : 100 ga teng
For sikli ichida o’zgaruvchining Qiymati 100 ga tenglansa yikl yakunlanganligini anglatadi.
S#va S da aniQlanayotgan maydonlar bilan ishlash farQini ko’rish mumkin.
Blokda Qism blok va undagi o’zgaruvchi ichki maydonda e’lon Qilingan bo’lsa, u asosiy blok
uchun o’zgaruvchi sifatida foydalanilmaydi.
Quyidagi dasturda ikki o’zgaruvchini bir noma’lum bilan e’lon Qilingan;
Using System;
Class NestVar {
Public static vold Main ( ) {
Int count;
For(count – 0; count < 10; count q count Q1);
Console. Writeline (sikl nomeri “ Qcount);
Int count;G’G’ buni e’lon Qilish shart emas ‘ ! ‘
For (count q 0; count < 2; count Q1)
Cjnsole. Writeline (“dasturda xatolik bor”);
}
}
}
Operatorlar
S# da juda ko’p operatorlar mavjud. Operatorlar spesifik matematik yoki mantiQiy operatsiyani
bajarilishi kerakligi to’g’risidagi ma’lumotni kompilyatorga yetkazib beruvchi amal xisoblanadi.
S# da to’rtta asosiy operatorlar (arifmetik, pobitli, mantiQiy, va tenglovchi operatorlar) va bir
necha Qo’shimcha operatorlar mavjud bo’lib, ular turli xolatlarda Qo’llaniladi. Mazkur bo’limda
arifmetik, mantiQiy va tenglovchi operatorlar xaQida so’z yuritiladi. Bulardan tashQari,
shuningdek o’zlashtiruv operatorlari xaQida xam ma’lumotlar berilgan. Bitma-bit asosidagi va
boshQa operatorlar xaQidagi ma’lumotlar esa keyinroQ beriladi.
Arifmetik operatorlar
S# da Quyidagi arifmetik operatorlar aniQlangan
Operator
Ma’nosi
Q
Qo’shuv
-
Ayirish (unitar minus)
*
Ko’paytirish
G’
Bo’lish
Modul bo’yicha olish (QoldiQ)
Q
Inkrement
-
Dekrement
Ko’paytirish, ayirish, Qo’shish operatorlari boshQa programmalash tillari kabi S# da xam bir xil
ma’noga ega. Arifmetik operatorlarning funksiyasi ma’lum bo’lishiga Qaramay u bir Qancha
tafsilotlarni bilishni talab Qiladi. Bo’lish operatorini QoldiQsiz bo’lish xolatida agar 10G’3
bo’lsa natija 3 ga teng bo’ladi. Bu xolatda natijani QoldiQ Qismini modul bo’yicha olish amali
orQali olish mumkin. Mazkur operator S# dagi kabi boshQa programmalash tillarida xam bir xil
ma’noga ega. S# da modul bo’yicha olishbutun sonlar uchun xam Qo’llanishi mumkin va
Quyida modul bo’yicha olish operatorining funksiyasi tasvirlangan.
using System
class Fodbeto
public static void main ()
int result
double result
1 result – 0 G’ 3
rem – 10. 3
cresult – 10.0 G’ 3.0
rem 10.0 G’ 3.0
Programmadan Quyidagi natija olinadi
Butunsonli bo’lish natijasi 3 ga teng
QoldiQ 1
double asosida bo’lish 10.0 G’3.0
QoldiQ 3.3333333333333333333 ga teng
Ko’rinib turibdiki, modul bo’yicha olish operatori butun sonlar bilan ishlash jarayonida natijani 1
gacha Qaytaradi.
Inkrement va dekrement operatorlari
Inkrement (QQ) va dekrement (--) operatorlari xaQida 1-bo’limda to’xtalib o’tilgan edi. Bu
operatorlarning o’ziga xos xususiyati algoritmga pereminon siklini o’zgartirish vazifasi
yuklatilganda ularni axamiyatini oshadi. Inkrement va dekrement operatorlarini Qanday
ishlashini Quyida ko’rib chiQamiz. Inkrement operatori o’zining operandasiga birlik Qo’shsa,
dekrement operatori esa o’zining operandasidan birlik ayirib tashlaydi. O’z navbatida
x-xq1 operatori xuddi shu kabi funksiyani bajaradi.
va xQ operatori esa
xQxq1 xuddi mazkur funksiyaga o’xshash vazifani bajaradi
Bu ikki operatorlar prefiks siftida opreandagacha yoki postfiks sifatida opreandadan keyin xam
ko’rsatilishi mumkin. Masalan
G’ y-2 operatorini Quyidagicha yozish mumkin.
-x operator operandagacha ko’rsatiladi yoki
x-G’G’ operator operandadan keyin ko’rsatiladi.
Mazkur namunada inkrement operatori ikki usul bilan ko’rsatilgan bo’lib, ular orasida farQ
yo’Q. Agar inkrement va dekrement operatorlari ifodaning asosiy Qismi sifatida Qo’llanilsa,
operatorlar operandaga nisbatan joylashuviga nisbatan blok kod algoritmini bajarilishiga
bog’liQ. Agar operator operandaga nisbatan oldinda joylashsa S# aralashma mazmunini
kattalashtiradi. Agar operator operandadan so’ng ko’rsatilsa, C# aralashma ifodasini
kattalashtiradi va buni Quyidagi misolda ko’rishimiz mumkin.
x0
Qu
Inkrement va dekrement operatorlarining mazkur xususiyatlari algoritmlar tuzishda Qo’llaniladi.
Tenglovchi va mantiQiy operatorlar
Tenglovchi operator atamasidagi tenglovchi so’zining ma’nosi bir amalni ikkinchisiga
solishtirgan xoldagi berilgan baxo sifatida va mantiQiy so’zi esa ifodadagi amallarni bog’lash
usuli deb Qarash mumkin. Tenglovchi operatorlar natijali amal bajarishi bulevo moxiyatli deb
xisoblash mumkin va bu operatorlar ko’p xollarda mantiQiy operatorlar bilan birgalikda ishlaydi.
Shuning uchun ularni birgalikda ko’rib chiQish mumkin.
Quyida tenglovchi operatorlar keltirilgan.
Opreator
Mazmuni
--
Teng
-_
Teng emas
>
Dan katta
<
Dan kichik
>-
Katta yoki teng
Kichik yoki teng
Quyida esa mantiQiy operatorlar keltirilgan
Operator
Mazmuni
&
AND (va)
!
OR (yoki)
^
XOR (yoki dan mustasno)
&&
Short circuit AND (va tez operatori)
!!
Short circuit OR ( yoki tez operatori)
1
NOT (yo’Q)
Tenglovchi va mantiQiy operatorlar amallarni bajarish natijasi mazmun tipi xisoblanadi.
S# da operatorlar barcha ob’ektlar uchun ularni teng va teng bo’lmagan predmet bilan
solishtirish uchun xam Qo’llanilishi mumkin. Shuningdek barcha tenglovchi operatorlar barcha
turdagi sonli ma’lumotlar uchun Qo’llaniladi. BiroQ bool tipidagi ifodalar faQatgina tenglik va
tenglik bo’lmagan predmetlar uchun solishtirilishi mumkin bo’lsada, true va false ifodalari
tartiblanmagan. Masalan true > false ifodasi S# da mazmunga ega emas. MantiQiy operatorlar
uchun esa operanda bool tipida bo’lishi zarur. &, !,^, 1 operatorlari o’z navbatida AND, OR,
XOR, NOT kabi mantiQiy operatsiyalar asoslari Qullab-Quvvatlaydi va u Quyidagi tablitsada
tasvirlangan.
p
q
p&q
p
q
p^q
false
false
false
false
false
true
true
false
false
true
true
false
false
true
true
true
true
true
false
false
false
true
true
Tablitsadan ko’rinib turibdiki, amal natijasiga ko’ra XOR operatorining faQatgina bitta
operandasi true mazmuniga ega bo’lsa, XOR operatori true mazmuniga ega bo’ladi.
Quyida tenglovchi va mantiQiy operatorlar tomonidan bajarilgan dasturni ko’rib chiQamiz.
G’G’ Dastur faQat mantiQiy va tenglovchi operatorlar yordamida G’G’Qilingan.
using system
class Rel.Log.Ops {
public static void Main () {
int i, j;
bool bl, b2;
1-10;
j-11;
if (1
if (1
if (1 !-j) Console.WriteLine (“1!-j”);
if (1--j) Console.WriteLine (“Mazkur Qator kiritilmaydi.”) ;
if (1>-j) Console.WriteLine (“Mazkur Qator kiritilmaydi.”) ;
if (1>j) Console.WriteLine (“Mazkur Qator kiritilmaydi.”) ;
b1-true
b2-false
if (b1 & b2) Console.WriteLine (“Mazkur Qator kiritilmaydi.”) ;
if (b1 & b2) Console.WriteLine (“b1 & b2 ifodasini xisoblash natijasi true Qiymatiga ega
bo’ladi.”)
if (b1 ! b2) Console.WriteLine (“(b1 & b2) ifodasini xisoblash natijasi true Qiymatiga ega
bo’ladi.”)
if (b1 ^ b2) Console.WriteLine (“b1 ^ b2 ifodasini xisoblash natijasi true Qiymatiga ega
bo’ladi.”)
Dasturni bajarilishi Quyidagicha bo’ladi:
1.
<j
1.
<-j
1 !-j
Tez mantiQiy operatorlar
S# da mantiQiy operatorlarning boshQa turlari ya’ni tez turi xam mavjud bo’lib, operatsiyalar
tezroQ bajarilishiga Qaratilgan. Ularni Qanday ishlashini Quyida ko’rib chiQamiz. Agar AND
opetatorining birinchi operandasi false bo’lsa, boshQa operandalar Qanday bo’lishidan Qat’iy
nazar natija false bo’ladi.
AND tez operatori && belgisi bilan belgilansa, OR operatori esa ! bilan belgilanadi. Odatiy va
tez operatorlarining asosiy bittagina farQi shundaki, tez operatorlarda operandani faQatgina
birinchisiga yoki zaruriyat tug’ilsagina ikkinchisiga e’tibor beriladi.
Quyida AND tez operatorining Qo’llanilishi keltirilgan. Dastur uzlukli d martali ifodani n
ekanligini aniQlaydi. Bu amal esa modul bo’yicha olish operatori yordamida amalga oshiriladi.
Agar nG’d Qoldig’i nolga teng bo’lsa, uzlukli d ifodasi n ga bo’linadi. Shunga Qaramay modul
bo’yicha olish operatori operatsiyada bo’lish amalini bajarsada, AND esa natijani olga
tenglashtiradi.
Bo’linmani nolga teng ekanligini tekshirishda operator dastlab ifodalarni teng yoki teng
emasligini tekshirib ko’radi. Agar teng bo’lsa operator amalni (bo’lishni) to’xtatadi. Dasturda
birinchi xolda bo’linuvchi ikkiga teng bo’lsa operatsiya modul bo’yicha olish operatori
yordamida amalga oshiriladi. Agar bo’linuvchi nolga teng bo’lsa, operatsiyaning modul bo’yicha
olish operatori yordamida amalga oshirilishi to’xtatiladi. Oxirgi uchinchi xolatda AND odatiy
operatori Qo’llaniladi va bunda ikkala operanda baxolanadi va natijada nolga bo’lishda xatolik
yuz beradi.
Proekt 2-2. MantiQiy operatorlar chinligi tablitsasi xulosasi
Mazkur proekt mantiQiy operatorlar chinligi tablitsasini ekranga chiQarib beradigan programma
yaratishga Qaratilgan. Dasturda S# elementlari xam ishtirok etib, ulardan biri yescape dir.
Shuningdek proektda arifmetik va mantiQiy operatorlarning afzallik tomonlari xam ko’rib
o’tiladi.
BosQichli instruksiya
1.
YAngi fayl yarating va uni Logu-alOpTable.cs deb nomlang
2.
Tablitsa ustunlarini to’g’irlash uchun yescape dan foydalanib Qatorlarga tabulyatsiya
elementlarini Qo’ying.
3.
Tablitsaning xar bir yangi Qator uchun tabulyatsiya elementlaridan foydalaning
4.
Quyida Logu-alOpTable.cs faylini dastur kodi keltirilgan.
G’*
2-2 proekt
*G’
5.
Amallarning bajarilishi natijasida Quyidagi tablitsa kelib chiQadi.
6.
S# operatorlarini mantiQiy operatorlarga nisbatan afzal ekanligiga e’tibor bering.
7.
MustaQil ravishda dasturni o’zgartirishga xarakat Qiling.
Professionallar javobi
Savol. S# da odatiy operatorlarning axamiyatini nimadan iborat va tez operatorlarning effektiligi
nimadan iborat?
Javob. Ba’zan operatsiya birinchi va ikkinchi operandlarni talab Qiladigan vaziyatlar xam
bo’ladi. Shuning uchun xam odatiy operatorlar Qo’llaniladi va uni Quyidagi programma bilan
ifodalash mumkin.
DaQiQali amaliyot
1.
Modul bo’yicha olish operatori Qanday ishlaydi. Unga Qanday ma’lumotlar Qullanilishi
mumkin.
2.
MantiQiy operatorlar uchun Qanday ma’lumotlar Qo’llaniladi.
3.
Tez operatorlar xar doim xam barcha operandalarni baxolaydimi.
O’zlashtiruvchi operatorlar
Biz mazkur kitobda o’zlashtiruvchi operatorlardan ko’p marotaba foydalandik va uni xozir
to’laroQ o’rganamiz. O’zlashtiruvchi operator tenglikni yakka (bitta) belgi bilan ko’rsatadi.
Mazkur operator boshQa dasturlash tillarida bo’lgani kabi C# da xam bir xil ishlaydi va bir xil
mazmunga ega. U Quyidagi sintaksis bilan belgilanadi:
var- expression;
O’zlashtiruvchi operatorning siz bilmagan bitta QiziQarli xususiyati bor. U “o’zlashtirma zanjir”
xosil Qiladi.
Misol tariQasida Quyidagi kod fragmentini ko’rishimiz mumkin.
int x,y,z;
x-y-z—100; x,y,z, 100 ga bog’lanmoQda.
YUQoridagi kod fragmentda x,y,z, 100 ga bog’lanishini kuzatish mumkin. Bunda operator
chapda, natija echa o’ng tomonda joylashadi. O’z navbatida zq100 ifodasi 100 ifodasi bilan bir
xil demakdir. “o’zlashtirma zanjir” dan foydalangan xolda bir nechta amallarni bir vaQtning
o’zida bajarish imkoniyati mavjud.
O’zlashtirishning tarkibli operatorlari
SG’SQQ da bo’lgani kabi S# da xamo’zlashtirishning tarkibli operatorlari bo’lib, bunda
arifmetik operatorlar o’zlashtiruvchi operatorlar bilan aralashgan bo’ladi. Mazkur operatorlarni
Quyidagi misol orQali ko’rishimiz mumkin.
x-xQ10; ifodasi o’zlashtirma operatorlari tomonidan
xQ-10; Qilib olinishi mumkin.
-Q operatorlari shuni ko’rsatadiki, mazkur jarayonda kompilyator x ni xQ10 tarzida o’zlashtirib
oladi.
YAna bir misol keltirib o’tamiz.
xqx-100 ifodasini xq100 tarzida yozish mumkin.
Bunda operator x operatorini o’zlashtirib x-100 tarziga olib keladi.
Barcha mantiQiy operatorlar uchun o’zlashtirishning tartibli operatorlari mavjuddir. Mazkur
operatorlarning sintaksisi Quyidagicha ifodalash mumkin.
var op q expression
Shunday ekan C# Quyidagi tarkibli o’zlashtiruvchi operatorlarga ega bo’ladi.
Qq -q *- G’%- &q !- ^q
Tarkibli operatorlarni ularni analoglariga nisbatan ikkita asosiy xususiyatga ega bo’ladi.
Birinchidan ular ixcham bo’lib, ikkinchidan ular Qo’llanilayotgan vaQtda kompililanuvchi kod
tezligini oshiradi. Shuning uchun tarkibli o’zlashtiruvchi operatorlar C# dasturlashda ko’p
Qo’llaniladi.
O’zlashtirish operatsiyalarida almashtiruv tiplari
Dasturlashda ko’p xollarda bir-biri bilan o’zlashtirilgan Qiymatlar Qo’llaniladi. Bunda
dasturlovchi bir tipli Qiymatni ikkinchi tipga o’zlashtirib olishi mumkin. O’zlashtirish
operatsiyalarida agar turli tipdagi ma’lumot Qo’llanilsa, tip bo’yicha o’zgaruvchi kattalik
operatordan o’ng tomonda joylashadi va chap tomondagi o’zgaruvchi avtomatik tarzda
almashtiriladi. C# tilida tiplar QattiQ boshQaruv ostida bo’ladi, lekin bu tiplar bir-biri bilan
o’zaro bog’langan aloQada bo’ladi. BiroQ barcha tiplar xam o’zaro mutanosiblikka ega emas.
Masalan bool va int tiplari nomutanosibdir. O’zlashtirish jarayonida bir tipga mansub ma’mot
ikkinchi tip bilan Quyidagi xolatlarda amalga oshadi.

ikkala tiplar mutanosib bo’lsa

oxirgi tip (chap) boshlang’ich (o’ng) tipdan katta bo’lsa
Mazkur shartlar bajarilgan xolatlarda kengaytirilgan akslantirish amalga oshadi. Shunga
Qaramay variabel tipidagi long va doable lar uchun avtomatik akslantirish mavjud bo’lib, bunda
teskari avtomatik akslantirish yuz bermaydi va bu dastur noto’g’ri bo’ladi. YUQorida ko’rsatib
o’tilgan cheklovlarga to’ldirish maQsadida yana shuni aytish lozimki, decimal yoki float va
double tiplarida avtomatik akslantirish yuz bermaydi va o’zgaruvchi tiplar bir-biri bilan
nomutanosib bo’ladi.
Nomutanosib tipli ma’lumot o’rtasida tartibga keltirish operatsiyalarini bajarish
Avtomatik akslantirish juda Qulay bo’lishiga Qaramay, dasturlashning barcha talablariga javob
bermaydi. Ularda faQatgina mutanosib tiplar uchun kengaytirilgan akslantirish mavjud. Tiplarni
tartiblash – bir tip ma’lumotni ikkinchi tip ma’lumotga akslantiruvchi kompilyator
instruksiyasidir. Tiplarni bunday akslantirish juda aniQlik bilan amalga oshadi. Tiplarni tartilash
Quyidagicha sintaksisga ega bo’ladi:
(target-type) experesion
Chekli tip (target-type) ifodani Qay tarzda tartibga keltirish ekanligini ifodalaydi. Agar xG’u
ifodasini int ifodasi tarzida akslantirish kerak bo’lsa uni Quyidagicha yozish mumkin.
double.e.x.y,
G’G’
(int) (xG’y)
X va u o’zgaruvchilari double tipiga tegishli ekanligini xisobga olgan xolda, mazkur misolda
tipni tartiblash ifodani int tipiga bo’lish orQali natija olingan. x va u uchun Qo’llanilgan
yumaloQ Qavs katta axamiyatga ega. Aks xolda tipni tartiblash bo’lish natijasiga emas balki
faQatgina x o’zgaruvchisiga tegishli bo’lib Qoladi xolos. Agar tipni tartiblashda jarayonida
QisQartirilgan akslantirish yuz bersa ma’lumot oxiriga yetmay Qolishi (yo’Qotilishi) mumkin.
Misol tariQasida long va int tipidagi ma’lumotlarni tartiblash jarayonida long tipiga xos
ma’lumotlar int tipiga mos Qiymat chegarasidan (diapozon) chiQib ketadi va eski razryadli bitlar
o’chib ketadi va ma’lumot o’chib ketadi. Quyida mazkur programmani ishlash prinsipi
keltirilgan.
Dastur natijalarini Quyidagi ifodalash mumkin
Butun x,u ifodasi 00 ga teng
Qiymat b 00 ga teng
Qiymat b 1 ga teng
ch
Mazkur natijani tartiblash dasturida bo’lish natijasida ma’lumotni yo’Qotilishini kuzatishimiz
mumkin. 257 o’zgaruvchisini o’zlashtirish jarayonida xam ma’lumot yo’Qotiladi, chunki 257
sonli belgilangan tip maksimumidan yuQoridir.
DaQiQali praktikum
1.
Tiplarni tartiblash operatsiyasi nima?
2.
Tiplarni tartiblash jarayonisiz short tipiga mos Qiymatni int tipiga moslab o’zlashtirish
mumkinmi?
3.
xqxQ23 operatorini boshQa usullar bilan yozib ko’ring.
Operatorolar afzalligi
2.3. tablitsada C# da Qo’laniladigan barcha opreatorlar yuQoridan past tomonga Qarab
keltirilgan. Shuningdek keyinchalik tanishtiriladigan operatorlar xam ko’rsatib o’tilgan.
Tablitsa 2.3. C# operatorlarini afzalligi
Eng yuQori
() [] QQ (postfiks) -(postfiks) checked new
sizeof typeof unchecked
! - (cast) Q (unarli) -(unarli) QQ(prefiks) -(prefiks)
* G’ %
Q<<>>
<> - is
q q !q
&
^
!
&&
!!
?
q op q
Eng pastki
Ifoda
Operatorlar, o’zgaruvchilar va literallar ifodaning tarkibiy Qismi xisoblanadi. Ifoda C#
dasturlash tilida mazkur tarkibiy Qismlarning kombinatsiyasidan kelib chiQadi. Agar siz ozgina
bo’lsa xam dasturlash bilan shug’ullangan bo’lsangiz (xech bo’lmaganda algebra bilan) buni
sintaksisini keltirib chiQara olasiz. BiroQ ishlash jarayonida Quyida ta’kidlanadigan Qoidalarga
amal Qilish zarur bo’ladi.
Ifodalarda tiplarni akslantirilishi
Ifodalarda ikki va undan ortiQ tipli ma’lumotlarni birgalikda Qo’shish imkoniyati mavjud bo’lib,
ular mutanosib xisoblanadi. Masalan siz Q va – son tipli ma’lumotlarni birgalikda Qo’shishingiz
mumkin.
Akslantirish bevosita S# da Qabul Qilingan ifodalarda tiplarning avtomatik akslatirilishi Qoidasi
asosida amalga oshadi. Quyida arifmetik operatsiyalar uchun mazkur Qoida asosidagi algoritm
keltirilgan.
Agar bir operand decimal tipiga mansub bo’lsa, ikkinchi operand xam avtomatik tarzda decimal
tipida akslantiradi.

Agar operandlardan biri double tipiga mansub bo’lsa, Qolgani xam avtomatik tarzda shu
tipda akslantiriladi.

Agar operand float tipiga mansub bo’lsa, ikkinchisi xam avtomatik tarzda shu tipda
akslantiriladi

Agar operandlardan biri along tipiga mansub bo’lsa, Qolgani xam avtomatik tarzda shu
tipda akslantiriladi

Agar operand lera tipiga mansub bo’lsa, ikkinchi operand avtomatik tarzda long tipida
akslantiriladi

Agar operandlardan biri long tipiga mansub bo’lsa, ikkinchi operand sb, te, short bo’lsa,
barcha operandlar avtomatik tarzda long tipda akslantiriladi

Agar bir operand line tipiga mansub bo’lsa ikkinchi operand avtomatik tarzad int tipida
akslantiriladi.

Agar yuQoridagi Qoidalardan chetga chiQish xolatlari bo’lsa, ikkala operand xam short
tipida akslantiriladi.
YUQorida keltirilgan avtomatik tarzda akslantirish Qoidalariga e’tibor Qarating. Barcha tipli
ma’lumotlar xam bir-iri bilan mutanosib bo’lavermaydi. Bularga misol Qilib float va decimal
tiplarini olish mumkin. Agar oxirgi Qoidaga e’tibor Qaratsangiz, mabodo biror bir Qoidaga mos
tushmaydigan vaziyatlarda ikkala operandlar xam avtomatik tarzda int tipiga o’tkaziladi. char,
sbyte, short, tipiga mansub Qiymatlar ifodada int tipiga o’tkaziladi. Bu protsess butunsonli
tiplarning avtomatik tarzdagi akslantirilishi deb nomlanadi. Bu esa barcha matematik
operatsiyalarning natijasi bitdan kam xolda saQlovchi tipga mansub ekanligini anglatadi.
Shuni yoddan ko’tarmaslik kerakki, avtomatik akslantirish jarayonida kutilmagan natijalar xam
kelib chiQishi mumkin. Masalan byte tiplari o’rtasida o’tkazilayotgan arifmetik operatsiyada
natijani int tipiga o’tganligini kuzatish mumkin. Bu esa umuman kutilmagan natijadir. Chunki
dasturlovchi o’zgaruvchilar tipini boshQarishi zarurdir. Butunsonlar tiplarini avtomatik tarzda
akslantirish Qoidasini Quyidagi dastur orQali ko’rish mumkin.
Agar bo’lish ifodasi b * b 1 o’zgartiruvchi bilan o’zlashtirilganda tiplarni tartiblash talab
Qilinmaydi. Chunki b o’zgartiruvchisini bo’lish jarayonida avtomatik tarzda int tipiga
o’zgartiriladi. Mabodo siz b * b o’zgaruvchisini b tarzida o’zlashtirmoQchi bo’lsangiz mazkur
tipni teskari tartibda byte tipiga o’tkazish zarur bo’ladi. Shuni esdan chiQarmaslik kerakki, agar
protsess davomida kutilmagan natija olinsa bu ifodadagi tiplarning nomutanosibligidandir. Bu
xolat ko’pincha char tipi bilan ishlayotgan paytda yuzaga keladi. Masalan Quyidagi kod
fragmentida char tipini natijalarini int tipiga aylantirilishini talab Qiladi.
char ch1 – ‘a’, ch2 – ‘b’;
(ch1-(char)’ch1’ – ch2);
Tipni tartiblashsiz ch1 va ch2 o’zgaruvchilarini ko’paytirish natijasida xosil bo’lgan Qiymat int
tipiga aylanadi, lekin o’zgaruvchilar char tipi tarzida o’zlashtirilmaydi.
Tiplarni tartiblash faQatgina tiplarni o’zlashtirish jarayonida tiplarni akslantirish uchungina
kerak bo’lmaydi. Masalan Quyidagi dasturda ifodani mayda natijalari uning double tipiga
o’tkazilishini talab Qiladi. Agar shunday Qilinmasa double tipi int tipiga ega bo’lardi va
ma’lumotning yo’Qolishiga olib keladi.
G’G’ mazkur dasturda ifodani hisoblash jarayonida tiplarni G’G’ tartiblash keltirilgan
using System
class UseCastpublic static void Main () {
int 1;
or (1 – 0; 1 < 5; 1 QQ)
Console.WriteLine( ‘ifodaning butunsonli natijasi’ -1Q”G’3: “ Q - G’3 );
Console.WriteLine (‘ifodaning mayda natijasi’) [0:#,##]”, (double) 1G’3;
Console.WriteLine ();
Quyida mazkur dasturni bajarilishi ko’rsatilgan.
Ifodani xisoblash natijasida xosil bo’lgan butun sonli natijasi 0G’3: 0
Ifodani xisoblash natijasida xosil bo’lgan QoldiQ sonli natijasi
Ifodani xisoblash natijasida xosil bo’lgan butun sonli natijasi 1G’3: 0
Ifodani xisoblash natijasida xosil bo’lgan QoldiQ sonli natijasi .33
Ifodani xisoblash natijasida xosil bo’lgan butun sonli natijasi 2G’3: 0
Ifodani xisoblash natijasida xosil bo’lgan QoldiQ sonli natijasi .67
Ifodani xisoblash natijasida xosil bo’lgan butun sonli natijasi 3G’3: 1
Ifodani xisoblash natijasida xosil bo’lgan QoldiQ sonli natijasi .1
Ifodani xisoblash natijasida xosil bo’lgan butun sonli natijasi 4G’3: 1
Ifodani xisoblash natijasida xosil bo’lgan QoldiQ sonli natijasi 1.33
Probel (bo’shliQ) va yumaloQ Qavslarning Qo’llanilishi
Dasturni tushunarligini oshirish uchun S# da tabulyatsiya va probel amallari ishlatiladi. Masalan
Quyidagi ikkita misollar bir xil lekin ularni ichidan ikkinchisini o’Qish osonroQdir.
10G’u*(127G’x);
10 G’ u * (127 G’ x) ;
YUmaloQ Qavslar uning ichida joylashgan operatorlar afzalligini oshiradi. Qo’shimcha tarzdagi
yumaloQ Qavslar ifodani xisoblash jarayonini sekinlashtirmaydi va xatolikka olib kelmaydi va
ifodani aniQligini va tushunarliligini oshiradi. Ko’rinib turibdiki, Quyidagi misollar ichidan
ikkinchisini o’Qish birmuncha osonroQdir.
x u 3 34*tempQ 2G’
x (y 3) (34*temp)G’2
2-3 Proekt. Kredit bo’yicha to’lov summalarini xisoblash
YUQorida ta’kidlanganidek, mazkur tiplar kunlik to’lovlarni xisoblash uchun xam juda
Qulaydir. Taklif etilayotgan dastur kredit bo’yicha to’lovlarni xisoblashga Qaratilgan (masalan
avtomobil sotib olish uchun). Mazkur proekt tiplarni tartiblash asosida va C# kutubxonasidan
foylanilgan xolda amalga oshiriladi.
To’lov summasini aniQlash uchun Quyidagi formuladan foydalaniladi.
Int Rate* (PrincipalG’PayPerYear)
Payment q ------------------------------------------------------1G’ ((IntRateG’PayPerYear)Q1) PayPerNumYear
Bu yerda Int Rate o’zgaruvchisi kredit orQali to’lov foizini bildirsa, Principal o’zgaruvchisi esa
eski balansni anglatadi. PayPerYear o’zgaruvchilari esa yil davomidagi to’lovni bildiradi va
NumYear esa yil xisobidagi to’lov vaQtini anglatadi.
BosQichli ko’rsatmalar
1.
YAngi fayl yarating va uni RegPay.cs deb nomlang
2.
Dasturda Quyidagi o’zgaruvchilarni Qo’llang
decimal Principle
decimal Pay
decimal PayPerYear
decimal NumYears G’G’ kreditning Qolgan vaQti
decimal Payment G’G’ to’lov miQdori
decimal numer, denom; G’G’ yordamchi o’zgaruvchilar
double b,e; G’G’ Pow usulining asosiy va chaQiruvining ko’rsatkich darajasi. E’tibor bering, xar
bir bosQichdan so’ng xar bir operatsiya uchun tavsiflar berilgan. Bu esa Qaysi o’zgaruvchi
Qanday funksiyani bajarishini bilish uchun Qulaylik yaratadi.
3.
Dasturning kod Qatoriga kredit to’g’risidagi spesifik informatsiyani kiriting. Dastur
uchun Quyidagi Qiymatlarni kiriting: eski balans 10 000 ming dollar, kredit foizi 7,5%,
yillik to’lov – 12, kredit uchun ajratilgan vaQt – 5 yil.
Principal – 10000
IntRate – 0.075m;
PayPerYear – 12.0m
NumYears – 5.0m
4.
moliyaviy xisob-kitobni amalga oshiruvchi kod Qatorini kirgizing
numer q IntRate * Principal G’PayPerYear
e – (double) – (PayPerYear * NumYears);
r – (double) (IntRate G’ PayPerYear) Q1;
denom q 1 – (decimal) Math.Pow.(b,e);
Payment – numerG’denom;
5.
Dastur operatorini xar oylik to’lov sifatida namoyon Qiladigan Qilib yakunlang.
Console.WriteLine (Oylik to’lov xajmi (0:S)”, Payment);
6.
Quyida dasturni to’la matni keltirilgan.
Proekt 2-3
Dastur kredit asosida oylik to’lovni xisoblash uchun mo’ljallangan.
Faylni RegPay.cs deb nomlang
*G’
using System;
classRegPay
Mazkur dasturni ishga tushirish uchun Quyidagi Qator kiritiladi.
G’G’G’G’
Mazkur dasturni amaliyotda Qo’llashdan oldin sinovdan o’tkazing.
Sinov savollari
1.
Nima uchun C# QattiQ tarzda oddiy tiplar uchun mumkin bo’lgan Qiymatlar va tavsiflar
uchun spesifiklishini namoyon etadi.
2.
C# ning simvolli tipi nima va u boshQa dasturlash tillari simvolli tiplaridan nimasi bilan
farQlanadi.
3.
O’zgaruvchi tip xoxlagan Qiymatni saQlashish xaQiQatmi, chunki barcha noldan katta
Qiymat mavjudku.
4.
Bitta kod Qatori va escape dan foydalanib, Quyidagi uch Qatorni to’ldiring
Birinchi
Ikkinchi
Uchinchi
5.
Quyidagi kod fragmentida Qanday xatolikka yo’l Qo’yilgan
For (- - 0, 1<-0, 1QQ)
Int sum
Sum – sum Q -;
Console.WriteLine (summa teng «Q» sum)
6.
Inkrementning postfiks (1QQ) va prefiks (QQ&) formalari o’rtasidagi farQlarni
tushuntirib bering
7.
N tez operatorini Qo’llash jarayonida 0 ga bo’lish jarayonidagi kod fragmentini yozing
8.
Ifodada byte va short tiplari Qanday akslantiriladi.
9.
Quyida keltirilgan tiplardan Qaysi biri decimal tipi bilan mutanosib bo’lolmaydi
a) float
b) int
c) short
d) byte
10. Qanday xolatlarda tiplarni tartiblash zarur bo’ladi
11. 1 dan 100 gacha bo’lgan diapozondagi dastur tuzing
12. mustaQil xolda proekt 2-2 uchun mo’ljallangan dastur tuzing. Bunda escape ketma-ketligi
o’rniga Qatorli kopiyalovchi literallardan foydalaning.
Havola tipidagi o’zgaruvchilar va berish operatori
Berish operatsiyasini bajarayotgan paytda havola tipidagi o’zgaruvchi odatdagi tipdagi
o’zgaruvchiga (masalan int tipidagi) nisbatan boshQacha ishlaydi. Agar siz odatdagi tipdagi
o’zgaruvchiga bersangiz bu yerda holat oddiy. Berish operatoridan chap tarafda turgan
o’zgaruvchi, ko’rsatilgan o’ngda turgan o’zgaruvchi Qiymatining nusxasini oladi. Havola
tipidagi bitta o’zgaruvchi Qiymatini boshQa o’zgaruvchiga berayotganingizda holat bir muncha
murakkab bo’ladi, chunki siz o’zgaruvchi havolani boshQa ob’ektga beryapsiz. Masalan,
Quyidagi kod fragmentini ko’rib chiQamiz:
Vehicle car 1 - new vehicle ();
Vehicle car 2 - car 1;
car 1 va car 2 o’zgaruvchilari turli xil ob’ektlarga tegishli bo’lib ko’rinishi mumkin, lekin bu
unday emas. Aslida ikkala o’zgaruvchi ham aynan bitta ob’ektga havola etiladi. car 2
o’zgaruvsiga car 1 o’zgaruvchining Qiymati berilayotganda, car 2 o’zgaruvchi car 1 havola
etilayotgan ob’ektga car 2 o’zgaruvchi havolasi berildai.
Demak, ob’ektga kirish car 1 o’zgaruvchi yordamida ham car 2 o’zgaruvchi yordamida ham
amalga oshirilishi mumkin. Masalan, car 1 berish operatsiyasi bajarilgandan so’ng ikkala Write
line () operatori ham bitta 26 Qiymatini chiQaradi.
Console. Writeline (car 1.mpg)
Console. Writeline (car 2.mpg)
car 1 va car 2 o’zgaruvchilarni bitta ob’ektga havola etilsada hech Qanday bir-biriga bog’liQ
emas. Masalan, Quyidagi kod fragmenti bajarilgach car 2 o’zgaruvchisi car 3 havola Qilingan
ob’ektga havola oladi. car 1 o’zgaruvchi havola etilayotgan ob’ekt o’zgaruvchisiz Qoladi.
Usullar.
Aytib o’tilganidek, ekzemplyar o’zgaruvchilar va usulga asosan tashkil etuvchilar ikki sinfdir.
Shu vaQtgacha bizning Vehicle sinfdagi dasturlar faQat ma’lumotlar saQlar edi va usul
saQlamas edi. Garchi faQat ma’lumot saQlovchi sinflar haQiQiy bo’lsada, ko’pchilik sinflar usul
ham saQlashadi. Usullar – kichik dasturlar bo’lib, sinfdagi ba’zi ma’lumotlarni boshQaradi va
ko’pchilik hollarda ma’lumotga kirishni ta’minlaydi. Odatda dasturning Qolgan Qismlari sinf
bilan uning usullari yordamida o’zaro ta’sirlashadi.
Usul bir yoki bir necha operatorga ega bo’lishi mumkin. Professional yozilgan S kodda har bir
usul faQat bitta vazifani bajaradi. Usul nomi sifatida har Qanday mavjud identifikatordan
foydalanish mumkin. Kalit so’zlar usul nomi bo’lishi mumkin emas, main nomi usul uchun
rezerflangan bo’lib, undan dasturni bajarish boshlanadi. Dastur matnida usullar Quyidagicha
belgilanadi: metod nomidan keyin bir juft dumaloQ Qavs Qo’yiladi. Masalan, agar usul nomi
getvar bo’lsa, uni dasturga chaQirish uchun getvar () ko’rinishida yoziladi. YOzishning bunday
formasi dasturda o’zgaruvchi va usul nomini farQlash uchun Qo’llaniladi:
Usulning umumiy sintaksisi Quyidagicha ko’rinishda bo’ladi:
Bu yerda access so’zi- modifikator bo’lib, dasturiningizning Qaysi Qismlari usulga kirishi
mumkinligini ko’rsatadi. Aytib o’tilganidek modifikator albatta bo’lishi shart emas, agar u
bo’lmasa usulga e’lon Qilingan sinf chegarasiga kirish mumkin. Hozircha biz barcha usullarni
ret sifatida e’lon Qilishimiz mumkin, shuning uchun ham ular dasturning istalgan joyidan kod
bilan chaQirilishi mumkin.
Sintaksisdagi ret-type Qo’shilmasi usul bilan Qaytariladigan ma’lumot tipini bildiradi. Bular har
Qanday tipdagi mavjud ma’lumotlar yoki siz tomoningizdan yaratilgan har Qanday Qiymatni
Qaytarmasa u void tipiga ega deb ko’rsatilishi shart. Name so’zining o’rniga usul nomi
ko’rsatiladi. Bu har Qanday mavjud identifikator bo’lib, o’sha ko’rinish oblastida mavjud sinflar
nomini takrorlamasligi kerak. Usul nomidan keyin parameter-list (parametrlar ro’yxati) ya’ni
vergul bilan ajratilgan “tip - identifikator” juftlarining ketma-ketligi keladi. YA’ni parametr
yordamida usulga dasturlash tipi albatta ko’rsatilgan Qiymatlar beriladi. Parametrlar asosan
o’zgaruvchilar bo’lib, usulni chaQirish paytida unga yetkaziladigan argumentlar Qiymatini
Qabul Qiladi. Agar metod parametrga ega bo’lmasa, parametrlar ro’yhati bo’sh bo’ladi.
Usulni vehicle sinfiga Qo’yish
Biz ilgariroQ aytib o’tganimizdek, sinf usullari odatda ma’lumotlar bilan ishlaydi va o’sha sinfga
kirishni ta’minlaydi. YUQorida keltirilgan yoQilg’i baki to’la bo’lgan avtomabilning bosib
o’tadigan masofasini o’lchaganda, masofa Qiymatini topish uchun avtomabilning bir gallon
yoQilg’i bilan bosib o’tgan masofasini yoQilg’i balon hajmining Qiymatiga ko’paytirganimizni
eslaymiz. Garchi texnik jihatdan biz barchasini to’g’ri bajargan bo’lsakda, bunday hisoblashlarni
bajarishda ushbu usul optimall usul emas. YUrishning maksimal uzunligini Vehicle sinfiga bosib
o’tilgan masofani o’lchash usuli Qo’shilganda sinfning orientirlangan ob’ektni tuzilishi
yaxshilanadi.
Vehicle sinfiga usul Qo’yilganda, uni sinfni yaratish paytida aniQlash kerak. Masalan, Vehicle
sinfiga tegishli versiya range () usulini tutadi, u esa avtomabilning bosib o’tgan yo’lini hisoblab
chiQaradi.
G’G’ range usuliga Vehicle sinfini kiritish
Using system ;
Class Vehicle(
Public int passengers; G’G’ yo’lovchilar miQdori
Public int fuelcap; G’G’ bakdagi yoQilg’ining hajmi
Public int mpg ; G’G’ joylashish masofasi
G’G’ avtomabillning bir marta yurishi
G’G’ yoQilg’i galloni.
G’G’ range usulini aniQlash .
Public void range ()range usuliga Vehicle sinfini kiritish
Console.Write Line (avtomabilning to’la bak bilan yurgan yo’li);
Bu dastur ishining natijasi Quyidagicha bo’ladi.
Mikro avtobus 7 ta passajirni tashishi mumkin.
Bu avtobus to’la yoQilg’i baki bilan 336 mil bosishi mumkin.
Sport avtomabili 2 ta passajirni tashishi mumkin.
Bu avtobus to’la yoQilg’i baki bilan 168 mil bosishi mumkin.
Endi dasturni barcha kalit elementlarini ko’rib chiQamiz
Range(1) usulidan boshlaymiz.
range (1) usulini e’lon Qilishning boshlanishi.
Kodning bu Qatorida parametrga ega bo’lmagan range nomli
Using system;
Class Vehicle;
Public int passegres; G’G’ yo’lovchilar miQdori
Public int fuelcap; G’G’ bakdagi yoQilg’ining hajmi
Public int mpg ; G’G’ joylashish masofasi
G’G’ avtomabillning bir marta yurishi
G’G’ yoQilg’i galloni.
Avtomabil to’la bakdagi yoQilg’i bilan yurish yo’lini hisoblash
Public int range();
Return mpg * fuelcap;
YOQilg’i miQdorini hisoblash usuliga berish parametri usulini kiritish.
Public double fuelneeded (int miles);
Return (double) miles G’ mpg;
Class Compfuel ( public ststic void Main()(Vehicle minivan qnew Vehicle ();
Vehicle sportscar q new Vehicle();
Double gallons;
Int dist-252;
G’G’Havola o’zgaruvchilarining minivan ob’ekti .
Minivan. Passengers -7;
Minivan. Fuelcap q14;
minivan . Mpg q12;
G’G’ Havola o’zgaruvchilarining sportscar ob’ekti .
Sportscar Passengers -7;
Sportscar Fuelcap q14
sportscar Mpg q12;
gallonsq minivan.fuelneeded(dist);
console.Writeline (“borish”Qdist Q “mikroavtobus mili” Q talab etiladi Q “gallons”Q “gallon
yoQilg’isi”.);
gallonsq sportscar.fuelneeded(dist);
console.Writeline (“borish”Qdist Q “mikroavtobus mili” Q talab etiladi Q “gallons”Q “gallon
yoQilg’isi”.);
console.Writeline (“borish”Qdist Q “sportmashinasi mili” Q talab etiladi Q “gallons”Q “gallon
yoQilg’isi”.);
Bu programmaning yakuni pastda keltirilgan.
Mikroavtobusning 252 mil yurishi uchun 12 gallon yoQilg’i talab etiladi.
Sportmashinasining 252 mil yurishi uchun 21 gallon yoQilg’i talab etiladi.
Mail () usuli ichidagi minivan range (); operatoriga e’tibor bering. Bu operator minivan ob’ekti
uchun range () usulini chaQiradi. YA’ni minivan ob’ekti uchun ob’ekti range () usuli
chaQiriladi. Buning uchun nomidan keyin nuQta () operatori keladigan ob’ekt nomi ko’rsatiladi.
Usul o’z ishini bajargandan so’ng, boshQaruv dasturining usul chaQirilgan nuQtasiga uzatiladi.
Dasturning bajarilishi kodning dasturli chaQirishdan keyingi Qatoridan davom etadi. Bu holda
minivan range () usuli chaQirilganda minivan avtomabilning bosib o’tadigan maksimal yo’li
haQidagi ma’lumotni chiQaradi. Har gal range () usuli chaQirilganda nuQta () operatoridan
chapda joylashgan ob’ekt o’zgaruvchilari bilan ishlaydi.
range () usulini aniQlashdagi muhim o’ziga xosligiga e’tibor bering Fuelcap va mpg
ekzemplyarining o’zgaruvchilari bevosita ko’rsatilmoQda (o’zgaruvchini ajratishda nuQta ()
operatori ishlatiladi aniQlatilmayapti va ob’ekt nomi ko’rsatilmayapti). Agar metod o’zi bilan
bitta sinfda aniQlangan o’zgaruvchi ekzemplyari bilan ishlaganda u o’zgaruvchiga ob’ektni aniQ
ko’rsatmasdan va nuQta () operatorini ishlatmasdan murojaat Qiladi. (YA’ni metod ichiga
ob’ekt nomini ikkinchi marta Qaytarishga ehtiyoj yo’Q). Bu ishlatilayotgan fuelcap va mpg
o’zgaruvchilari range () usuli chaQiriladigan ob’ektda aniQlangan o’zgaruvchilar nusxasiga
noaniQ murojaat Qiladi.
Usuldan boshQaruvni Qaytarish
BoshQaruv usuldan ikki holda Qaytariladi. Bu birinchidan agar ushbu usulni yopuvchi figurali
Qavs duch kelganda, ikkinchidan return operatori bajarilganda. return operatorning 2 ta formasi
mavjud. Bitta formasi void tipiga (Qiymatni Qaytarmaydigan) ega bo’lgan usullarda
Qo’llaniladi, ikkinchisi Qiymatni Qaytaradigan usullarda ishlatiladi.
void tipiga ega bo’lgan usullarga return operatorini bajarilishi usulning tezda ishni to’xtatilishiga
olib keladi. Shuning uchun bu usul odatda shartli belgilashdan keyin ko’rsatiladi, chunki
ma’lumotnomalarda Qolgan operatorlarning usul bajarilishi ma’noga ega bo’lmay Qolishi
mumkin.
return operatori Quyidagicha yoziladi
return
U bajarilayotgan vaQtda boshQaruv dasturining usul chaQirilgan nuQtasiga uzatiladi, bunda
usuldagi Qolgan kod tushirib Qoldiriladi. Misol tariQasida Quyidagi usulni ko’rib chiQamiz
public void myMeth (){
int i;
for ( iq0; i
if (iqq5) return; G’G’ Metod o’z ishini I o’zgaruvchi 5 Qiymatini Qabul Qilganda to’xtatadi.
G’G’ 5 belgi Qabul Qiladi.
console.Writeline ()
Bu yerda for sikli faQat 5 marta bajariladi, chunki o’zgaruvchi i ning Qiymati 5 ga teng
bo’lganda return operatori bajariladi.
Bitta usul ichida bittadan ko’p return operatori bo’lishi mumkin. Ko’pincha bunday operatorlar
bir necha shartli belgilari bo’lgan usullarda Qo’llaniladi. Masalan,
public void myMeth ()
G’G’ …
if (condition_1 ) return;
G’G’…
if (condition_2) return; G’G’
statements;
Bu usuldan boshQaruvni Qaytarish uch holda amalga oshadi:usulning so’nggi operatorlari
bajarilib bo’lgach, birinchi shartli belgi keyin ikkinchi shartli belgilash bajariladi. BiroQ usul
juda ko’p chiQish nuQtalariga ega bo’lsa, bu kodni destruksiyalaydi, shu sababli return
operatorlari keragidan ortiQ ishlatilmaslik kerak.
Usul bilan Qiymatni Qaytarish
void tipidagi usullar ko’p uchrab tursa ham, S dagi ko’pchilik usullar Qiymatni Qaytaradi.
Amalda Qiymatni Qaytarish Qobiliyati usulning muhim xususiyatini bildiradi. Siz usul
yordamida Qiymatni Qaytarishga misol ko’rgansiz, buni biz sondan kvadrat ildiz Qiymatni olish
uchun math.Sqrt () funksiyasi ishlatilganda, Qaytariladigan Qiymat operatsiyasini muvaffaQiyati
yoki muvaffaQiyatsizligini ko’rsatadi. Ba’zan Qaytaradigan Qiymat holat kodini tutishi
mumkin.(oldindan aniQlangan -1,0, va hak sonlar Qaytariladi.) Usul bilan Qiymatni Qaytarilgan
Qiymatlarni Qo’llash- dasturlashning ajralmas bo’lagidir.Usullar Quyidagi return forma
operatorini Qo’llab kod programmaga chaQiriladigan dasturlarni Qaytaradi.
return value;
Bu yerda Qo’yiladigan value so’zi Qaytariladigan Qiymat. Usullarning Qiymatni Qaytarish
xususiyatini bizga tanish bo’lgan range usulini takomillashtirish uchun ishlatish mumkin.
Avtomabilning bosib o’tishi mumkin bo’lgan maksimal masofa haQidagi ma’lumot o’rniga
range usulining yangi varianti maksimal masofa Qiymatini hisoblaydi va uni dasturga Qaytaradi.
Bunday yondashishning ustunliklaridan biri Qaytariladigan Qiymatni boshQa hisoblashlar uchun
ishlatish mumkinligidadir.
Keyingi dastur variantida modifikatsiyalangan range () usuli ekranga tegishli bo’lgan
ma’lumotlarni chiQarmaydi, balki hisoblangan Qiymatni Qaytaradi.
G’G’Dasturda Qaytariladigan hisoblangan Qiymatni ishlatish usullari namoyish etiladi.
Using system;
Class Vehicle;
Public int passegres; G’G’ yo’lovchilar miQdori
Public int fuelcap; G’G’ bakdagi yoQilg’ining hajmi
Public int mpg ; G’G’ joylashish masofasi
G’G’ avtomabillning bir marta yurishi
G’G’ yoQilg’i galloni.
Avtomabil to’la bakdagi yoQilg’i bilan yurish yo’lini hisoblash
Public int range();
Return mpg * fuelcap;
Class RetMeth{
Range () usuli belgini Qaytaradi.
public static void Main () {
Vehicle minivanq new Vehicle();
Vehicle sportcarq new Vehicle();
G’G’Havola o’zgaruvchilarining minivan ob’ekti .
int range1, range 2;
Minivan. Passengers -7;
Minivan. Fuelcap q16;
minivan . Mpg q21;
G’G’ Havola o’zgaruvchilarining sportscar ob’ekti .
Sportscar Passengers -7;
Sportscar Fuelcap q14
sportscar Mpg q12;
G’G’ Avtomobilning hisoblangan maksimal yurish masofasi
range1q minivan.range () ;
range2q sportcar range (); o’zgaruvchilar range1 va range 2 Qaytish belgilari
console.Writeline (“Minivan. Passengers ”Q “mikroavtobusning borib kelishi” Q
yo’lovchilarning joylashishi Q “range 1”Q “mil”.);
console.Writeline (“Sportscar Passengers” Q “sportmashinasining borib kelishi” Q
yo’lovchilarning joylashishi Q “range 2”Q “mil”.);
Bu dasturni bajarish natijasi Quyidagicha
G’G’Mikroavtobus 7 ta yo’lovchini 336mil masofaga olib borishi mumkin.
G’G’Sportmashinasi 2 ta yo’lovchini 168 mil masofaga olib borishi mumkin.
Bu dasturda range ( ) usulini chaQirish berish operatoridan o’ngda joylashadi, uning chan
tomonda range ()usuli bilan Qaytariladigan Qiymat beriladigan o’zgaruvchi joylashadi. Kod
Qatori bajarilgandan keyin,
range1q minivan.range () ;
o’zgaruvchi range1 havolanuvchi belgisi, o’zgaruvchi minivan ob’ekti ishlatilgandan
hisoblanadi.
Endi range ( ) int usuli int tipidagi Qiymatni Qaytaradi. Usul Qaytaradigan Qiymat tipini to’g’ri
ko’rsatish juda ham muhim (agar tipidagi ma’lumotni usul bilan Qaytarishga to’g’ri kelsa, usulni
e’lon Qilishda Qaytariladigan ushbu Qiymat tipini aynan ko’rsatish kerak) yuQorida keltirilgan
dastur sintaksisi bexato yozilgan bo’lsada, u juda effektiv yozilgan emas, chunki range 1va range
2 o’zgaruvchilariga kerak emas, chunki range1 usuli bevosita Writeline () operatori bilan Quyida
ko’rsatilgan
console.Writeline (“Minivan. Passengers ”Q “mikroavtobusning borib kelishi” Q
yo’lovchilarning joylashishi Q “range 1”Q “mil”.);
Bu holda Writeline operatori bajarishda Minivan usulini dasturning har Qanday joyidan
chaQirishimiz mumkin, agar Vehicle sinfidagi ob’ektning maksimal masofa kerak bo’lsa,
Masalan Quyidagi kodda range () usuli bilan Qaytariladigan Qiymatlar solishtiriladi.
if (v1.range ()>v2.range ())
console.Writeline (“Avtobusning v1to’la yoQilg’i baki bilan borib kelishi” Q v2 avtomabilning
joylashishi.);
Parametrlarni Qo’llash
Usulni chaQirayotganda unga bitta yoki bir necha Qiymat berish mumkin. Aytib o’tilganidek
usulga berilayotgan Qiymat argument deyiladi. Parametrlar usuldan keyin keladigan aylana Qavs
ichida ko’rsatiladi. Parametr ko’rsatiladigan sintaksis o’zgaruvchi ko’rsatiladigan sintaksisga
o’xshash bo’ladi. Parametr o’z usuli ko’rinishi chegarasida mavjud bo’ladi. Parametrning
Qo’yilish – usulni bajarish paytida argument Qiymatini Qabul Qilish, lekin u har Qanday
boshQa lokal o’zgaruvchi kabi xarakat Qiladi. Bundan keyin oddiy dastur keltirilgan bo’lib,
unda usulga Qiymat berish uchun parametr Qo’llaniladi. SqhNum sinfi ichida isEwen () usuli
true Qiymatini Qaytaradi, agar unga beriladigan Qiymat juft bo’lsa. Aks holda false Qiymatini
Qaytaradi. Usulga Qiymat uchun parametr Qo’llanilishini ko’rsatadigan oddiy dastur.
Bu dasturni bajarish natijasida Quyidagi Qatorlar chiQariladi.
10 soni juft
8 soni juft
isEwen () usuli 3 marta chiQariladi va unga har gal yangi Qiymat beriladi. Bu jarayonni kengroQ
ko’rib chiQvmiz, bunda isEwen () Qavs ichida ko’rsatiladi. isEwen () usuli 1 marta
chaQirilganda unga 10 Qiymat beriladi. 2- marta chaQirilganda 9 soni argument bo’ladi.
Uchinchi marta chaQirilganda 8 Qiymatni Qabul Qiladi. YAni parametr usuli 8 o’zgaruvchini
isEwen () suulini chaQirishda argument sifatida beriladigan Qiymatni Qabul Qiladi.
Proekt 4-1. YAratilgan sinf ma’lumotnomasi
Sinflar katta bloklardan tashkil topgan programmalardir. Chunki har bir blok funksiyalangan
aniQ xarakatlarni bajarishga asoslangan. Sinflar juda kichik va juda katta ham bo’lmasligi kerak.
Sinflar berilgan vazifani chalkashtirmasdan va destruksiyalab, kodlab, kamchiliklarsiz
funksiyalaydi. Ilmiy programmalarga o’tganda, programma tabiiy ishlay boshlaydi bu uning
Qimmatli programmaligini ko’rsatadi.
YAratilgan sinf ma’lumotnomasi proek 3-3 dan foydalanamiz. Dastlab yaxshi fikr topamiz.
Birinchidan, ma’lumotnoma sistema bitta mantiQiy blok yaratadi. Bir necha topshiriQlar
berilganda sitaksis operator S ekranda hosil bo’ladi, blokli fuksiyalar aniQ aniQlanadi.
Ikkinchidan, programmistga kerakli ma’lumotnoma sistemalar aniQlanadi va Qo’shimchalar
Qo’shish kerak bo’lsa, eski sinfdan bitta ekzemplyar olinadi. BoshQa ma’lumotlar kerak bo’lsa
programmaning Qo’shimcha effektidan foydalaniladi.
Instruksiyaning ketma-ketmaligi.
1.
YAngi fayl yarating va uni Help classdemo.cs. shaklida nomlang. Chunki
programmaning kodiga Qaytmasligi uchun va uni help 3.cs. fayli orQali nusxa olinadi.
Koddan o’zgaruvchan ekzemplyarga yetshish uchun bu o’zgaruvchan aniQlangan sinfni bir
Qismi bo’lgan ob’ektni nomi operator nuQta va o’zgaruvchini ismi ko’rsatilishi zarur. Shu
o’zgaruvchan aniQlangan sinfni bir Qismi bo’lgan koddan o’zgaruvchan ekzemplyarga yetishish
uchun to’g’ridan-to’g’ri o’zgaruvchanni ismini ko’rstish mumkin.
2. Argument – bu metodni chaQirishda unga beriladigan Qiymat.
3. Metoddan boshQaruvni Qaytarish Return operatori yordamida amalga oshirilishi mumkin.
Agar metod void tipga ega bo’lsa, metod chaQirib olinganni Qaytarish yopiQ figurali Qavs bilan
amalga oshiriladi. BiroQ (ne- void) tipdagi Qiymatni Qaytarish uchun Return operatoridan
foydalanish zarur, ya’ni yopiQ figurali Qavsga erishilganda metoddan boshQaruvni Qaytarish
mumkin emas.
1. helpon () usulini yaratish.
Public void helpon (char what) (switch (what) ( case ‘1’:
Console.Writeline (“operator”if:g’n”);
Console.Writeline (“if(condition)ststement;”);
Console.Writeline (“else ststement;”);
Break;
Case ‘2’:
Console.Writeline (“operator switch:g’n”);
Console.Writeline (“switch expression)(“);
Console.Writeline (“ case constant:”);
Console.Writeline (“ statement sequence”);
Console.Writeline (“break ;”);
Console.Writeline (“ G’G’ ”);
Console.Writeline (“ (”);
Break;
Case ‘3’:
Console.Writeline (“Sikl for :g’n”);
Console.Writeline (“while(condition;iteration)”);
Console.Writeline (“statement;”);
Break;
Case ‘4’:
Console.Writeline (“sikl while:g’n”);
Console.Writeline (“while (condition) statement;”);
Break;
Case ‘5’:
Console.Writeline (“sikl do-while:g’n”);
Console.Writeline (“do (“);
Console.Writeline (“ (“statement;”);
Console.Writeline (“)while (condition);”);
Break;
Case ‘6’:
Console.Writeline (“operator break:g’n”);
Console.Writeline (“Break; or break label;”);
Break;
Case ‘7’:
Console.Writeline (“operator continue:g’n”);
Console.Writeline (“continue;or continue label;”);
Break;
Case ‘8’:
Console.Writeline (“operator goto:g’n”);
Console.Writeline (“goto label;”);
Break;
Console.Writeline ();
4. showmenu () usulini yaratish ketma-ketligi:
Public void showmenu () (
Console.Writeline (“sintaksisda ma’lumotnoma:”);
Console.Writeline (“ 1.Operator if”);
Console.Writeline (“ 2.Operator switch”);
Console.Writeline (“ 3.Davr for”);
Console.Writeline (“ 4.Davr while”);
Console.Writeline (“ 5. Davr do-while”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 7.Operator continue”);
Console.Writeline (“ 8.Operator gotog’n”);
Console.Writeline (Davr yoki operator tartib nomeriga Qaytish:”);
Console.Writeline (programmada ishni tugallash uchun q ga Qaytish:”);
)
5. Is valid () usulini yaratish:
Public bool isvalid (char ch) ( if (ch ‘1’ I ch> ‘8’  ch Iq ‘q’)return false;
Else return true;
6. Help sinfidagi usulni yarating:
Class Help
Public void helpon (char what) (switch (what)
( case ‘1’:
Console.Writeline (“operator”if:g’n”);
Console.Writeline (“if(condition)statement;”);
Console.Writeline (“else statement;”);
Break;
Case ‘2’:
Console.Writeline (“operator switch:g’n”);
Console.Writeline (“switch expression)(“);
Console.Writeline (“ case constant:”);
Console.Writeline (“ statement sequence”);
Console.Writeline (“break ;”);
Console.Writeline (“ G’G’ ”);
Console.Writeline (“ (”);
Break;
Case ‘3’:
Console.Writeline (“Sikl for :g’n”);
Console.Write (“for(init; condition;iteration)”);
Console.Writeline (“statement;”);
Break;
Case ‘4’:
Console.Writeline (“sikl while:g’n”);
Console.Writeline (“while (condition) statement;”);
Break;
Case ‘5’:
Console.Writeline (“sikl do-while:g’n”);
Console.Writeline (“do (“);
Console.Writeline (“ (“statement;”);
Console.Writeline (“)while (condition);”);
Break;
Case ‘6’:
Console.Writeline (“operator break:g’n”);
Console.Writeline (“Break; or break label;”);
Break;
Case ‘7’: Console.Writeline (“operator continue:g’n”);
Console.Writeline (“continue;or continue label;”);
Break;
Case ‘8’:
Console.Writeline (“operator goto:g’n”);
Console.Writeline (“goto label;”);
Break;
Console.Writeline ();
Public void showmenu () (
Console.Writeline (“sintaksisda ma’lumotnoma:”);
Console.Writeline (“ 1.Operator if”);
Console.Writeline (“ 2.Operator switch”);
Console.Writeline (“ 3.Davr for”);
Console.Writeline (“ 4.Davr while”);
Console.Writeline (“ 5. Davr do-while”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 7.Operator continue”);
Console.Writeline (“ 8.Operator gotog’n”);
Console.Writeline (Davr yoki operator tartib nomeriga Qaytish:”);
Console.Writeline (programmada ishni tugallash uchun q ga Qaytish:”);
)
Public bool isvalid (char ch) ( if (ch ‘1’ I ch> ‘8’  ch Iq ‘q’)return false;
Else return true;
7. Proekt 3-3 dan main usulini yangi help sinfi orQali yozish. Bu asosiy sinfni Main () Help
Class Demo .cs. nomi bilan nomlaymiz.
Usul to’liQ shaklda pastda keltirilgan.
Proekt 4-1.
Proekt 3-3 ma’lumotnoma help sinfiga asoslangan.
Using System;
Class help;
Public void helpon (char what)
(switch (what)
( case ‘1’:
Console.Writeline (“operator”if:g’n”);
Console.Writeline (“if(condition)statement;”);
Console.Writeline (“else statement;”);
Break;
Case ‘2’:
Console.Writeline (“operator switch:g’n”);
Console.Writeline (“switch expression)(“);
Console.Writeline (“ case constant:”);
Console.Writeline (“ statement sequence”);
Console.Writeline (“break ;”);
Console.Writeline (“ G’G’ ”);
Console.Writeline (“ (”);
Break;
Case ‘3’:
Console.Writeline (“Sikl for :g’n”);
Console.Write (“for(init; condition;iteration)”);
Console.Writeline (“statement;”);
Break;
Case ‘4’:
Console.Writeline (“sikl while:g’n”);
Console.Writeline (“while (condition) statement;”);
Break;
Case ‘5’:
Console.Writeline (“sikl do-while:g’n”);
Console.Writeline (“do (“);
Console.Writeline (“ (“statement;”);
Console.Writeline (“)while (condition);”);
Break;
Case ‘6’:
Console.Writeline (“operator break:g’n”);
Console.Writeline (“Break; or break label;”);
Break;
Case ‘7’: Console.Writeline (“operator continue:g’n”);
Console.Writeline (“continue;or continue label;”);
Break;
Case ‘8’:
Console.Writeline (“operator goto:g’n”);
Console.Writeline (“goto label;”);
Break;
Console.Writeline ();
Public void showmenu () (
Console.Writeline (“sintaksisda ma’lumotnoma:”);
Console.Writeline (“ 1.Operator if”);
Console.Writeline (“ 2.Operator switch”);
Console.Writeline (“ 3.Davr for”);
Console.Writeline (“ 4.Davr while”);
Console.Writeline (“ 5. Davr do-while”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 6.Operator break”);
Console.Writeline (“ 7.Operator continue”);
Console.Writeline (“ 8.Operator gotog’n”);
Console.Writeline (Davr yoki operator tartib nomeriga Qaytish:”);
Console.Writeline (programmada ishni tugallash uchun q ga Qaytish:”);
)
Public bool isvalid (char ch) ( if (ch ‘1’ I ch> ‘8’  ch Iq ‘q’)return false;
Else return true;
)
)
Class HelpClassDemo (
Public static void Main ( ) (
Char choice;
Help hlpobj-new Help;
For(;;) (
Do (
Hlpobj. Showmenu ( );
Do (
Choiceq(char) Console.Read ( );
)while (choiceqq ‘g’n’(choiceqq ‘g’r’);
While (lhlpobj.isvalid(choice) );
If (choice qq ‘q’)break;
Console. WriteLine(“g’n”);
Hlpobj.helpon(choice);
)
)
)
Programmani testdan o’tkazilganda funksiya o’zgarmasdan Qoldi. Bu programma prorammist
uchun ma’lumotnoma bazasi sistemasi vazifasini bajaradi.
Konstruktorlar.
O’tgan misollarda Vehicle sinfidagi har Qaysi ob’ektni Qo’llash uchun operatorlarni Quyidagi
ketma-ketligiga asoslangan Qiymatlarni Qo’lda belgilash zarur edi.
Minivan. Passengers -7;
Minivan. Fuelcap q14;
minivan . Mpg q12;
Bu usul hech vaQti S professional yozilgan programmalarda Qo’llanilmaydi, chunki bunda
birinchidan tasodifiy xato yuzaga kelish ehtimolligi mavjud, ikkinchidan S da konstruktordan
foydalanishna asoslangan bu masalani hal etishni boshQa usuli ko’zda tutilgan.
Konstruktor sinfi ob’ektni yaratish jarayonida initsiallaydi. U sinf nomiga mos keluvchi nom
bilan belgilanadi va usulga (ma’nosiga ko’ra) sintaksis o’xshash bo’ladi. Ammo konstruktorlarda
takrorlanuvchi turlar Qiymati aniQ ko’rsatilmaydi. Konstruktorning ma’no jihatidan umumiyligi:
class – name ( ) (
G’G’ konstruktorning kodi
)
Odatda konstruktorlar ma’lum sinflarning o’zgaruvchan ekzemplyariga boshlang’ich Qiymatni
berishda yoki ob’ektni to’liQ shakllantirishda initsiallash jarayonining istalgan bosQichida
Qo’llaniladi.
Hamma sinflar u aniQlangan yoki yo’Q bo’lishga Qaramasdan konstruktorlariga ega. Teng
holatda S da hamma o’zgaruvchan ekzemplyarlariga va hull mavjudligi ko’zda tutilgan.
Agar sinf uchun konstruktor aniQ belgilab olingan bo’lsa teng holatni konstruktordan
foydalanilmaydi.
Oddiy misolni ko’rib chiQamiz.
G’G’ Oddiy konstruktorga misol.
using System;
konstruktor myclass sinfi
class my class ( )( 
xqic;
)
(class consdemo {
public static void Main ( ) {
My class t1-new Myclass ( );
My class t2-new Myclass ( );
console. Writeline (t1.x Q “”Q t2.x.);
Ushbu misolda Myclass sinfidagi konstruktordan foydalanilgan.
public Myclass
x-10;
Konstruktor public ko’rinishida aniQlangan deb belgilab olamiz. Bu konstruktorlar kodi
myclass t1-new myclass ();
Bu konstruktor uning sinfi chegarasidan tashQaridan chiQarilganligi sababli Qilingan.
Konstruktor myclass sinfi 10 Qiymatini o’zgaruvchan X ekzemplyarini o’zlashritib oladi. Bu
konstruktor ob’ektni yaratishda new operatori deyiladi.
Masalan myclass t1kodi Qatorida. Konstruktor t1 ob’ektni yaratishda,X10 Qiymatigi t1
o’zgaruvchini berishda myclass operatori chaQiriladi. Shu narsa t2 ob’ektda ham bo’ladi.
O’zgaruvchan konstruktor t2 chaQirilgandan so’ng X10 Qiymatini oladi. Shunday Qilib,
programmaning bajarilishi natijasida Quyidagi Qiymatlar keltirib chiQaradi: 10 10.
Qiymatli konstruktorlar.
Oldingi misolda Qiymatsiz konstruktorlardan foydalanilgandi. Buni ayrim hollarda Qo’llash
mumkin, lekin ko’pchilik hollarda bir yoki bir necha parametrli konstruktorlardan foydalaniladi.
Qiymatlarni parametrda Qo’llanilishi uni metodda Qo’llanilishidek bo’ladi. Quyidagi misolda
Qiymatlarga ega bo’lgan konstruktor myclass sinfi keltirilgan.
G’G’ Qiymatlarga ega bo’lgan parametrni Qo’llanilishi.
using System;
class my class (
public int x;
public my class (int 1 )
x-i;
(class Parmconsdemo {
public static void Main ( ) {
My class t1-new Myclass ( );
My class t2-new Myclass ( );
console. Writeline (t1.x Q “”Q t2.x.);
Quyida shu programmani bajarilish natijalari keltirilgan. 20 88.
Konstruktorga Vehicle sinfini Qo’shish.
Konstruktor my class ( )ni my class ( ) sinfida o’zgaruvchan x ekzemplyarga boshlang’ich
Qiymatni beruvchi bitta parametr (int tipidagi –i o’zgaruvchi) mavjud. Demak my class t1 q new
Myclass (10) operatori bajarilgandan so’ng 10 Qiymat i parametrga uzatiladi va keyin x
o’zgaruvchan tomonidan o’zlashtiriladi.
G’G’ Vehicle sinfiga konstruktorni Qo’shish.
Vehicle sinfini ob’ektni yaratishda avtomatik ravishda o’zgaruvchan passegres ga
initsiallanuvchi konstruktorni Qo’shish orQali takomillashtirish mumkin. Kodni Vehicle sifini
yaratuvchi Qatoriga e’tiborni Qarating.
Programmada Vehicle sinfining konstruktori aniQlangan yangi versiyasidan foydalanilgan.
G’G’ Bu programmada Vehicle sinfining yangi turi Qo’llaniladi
Using system;
Class Vehicle;
Public int passegres; G’G’ yo’lovchilar miQdori
Public int fuelcap; G’G’ bakdagi yoQilg’ining hajmi
Public int mpg ; G’G’ joylashish masofasi
G’G’ avtomabillning bir marta yurishi
G’G’ Vehicle sinfining konstruktori .
Public Vehicle (int p, int f, int m){
passengersqp;
Vehicle sinfining konstruktori
fuelcapqf;
mpgqm;
)
G’G’ Metod avtomabil to’la bak bilan bosim o’tish mumkin bo’lgan maksimal masofa Qiymatini
Qaytaradi.
Public int range ();
Return mpg * fuelcap;
G’G’ Metod unga parametr sifatida beriladigan masofa Qiymatini bosib o’tish miQdorini
hisoblab beradi.
public double fuelneeded (int miles)
return (double) miles G’mpg;
)
)
class vehconsdemo {
public static void Main () {
G’G’ Vehicle sinfida ikkita ob’ekt yaratish. Konstruktordan foydalanib Vehicle sinfi ob’ekti
avtomabili xarakteristikasini uzatish.
minivan va sportcar ob’ektlarini yaratishda Vehicle ( ) konstruktor bu ob’ektlarni
o’zgaruvchanlariga boshlang’ich Qiymatlarini beradi. Har Qanday ob’ekt ko’rsatiladigan
argument bo’yicha initsiallanadi. Masalan kodni Qatorida
Vehicle minivan – new Vehicle (7, 16, 21);
Vehicle sportcar – new Vehicle (2, 14, 12);
double gallons;
int distq252;
gallonsqminivan.fuelneeded (dist);
console.Writeline (“borish”Qdist Q “mikroavtobus mili” Q talab etiladi Q “gallons”Q “gallon
yoQilg’isi”.);
gallonsq sportscar.fuelneeded(dist);
console.Writeline (“borish”Qdist Q “sportmashinasi mili” Q talab etiladi Q “gallons”Q “gallon
yoQilg’isi”.);
Oldingi versiyadagidek ushbu programmani ham bajarilishda ob’ektni yaratishda ( operatorini
bajarishda) 7, 16 va 21 Qiymatlar konstruktorga uzatiladi. Demak, passegres, mpg va fuelcap
ob’ekti tegishlicha 7, 16 va 21 Qiymatlarga ega bo’ladi.
Minut praktikumi.
1. Konstruktor nima? U Qachon bajariladi?
2. Konstruktorda Qaytariladigan Qiymatini tipi ko’rsatadiladimi?
New operatori
Sinf va konstruktorlar haQida bilib olganimizdan keyin New operatorini ko’rib chiQamiz. Bu
operator Quyidagi sintaksisga ega:
slass-var-new class-name ():
Bunda slass-var so’z birikmasi – class tipi o’zgaruvchanning nomi oldidan Qo’yilayotgan
yaratilayotgan o’zgaruvchanlik, class-name esa nusxasi yaratilayotgan sinfning nomi. (Aytish
mumkinki, slass va class-name so’zlari o’rniga nusxasi yaratilayotgan bir sinf nomi ko’rsatiladi.
Aylanma Qovuslar bilan tugalanadigan sinf nomi sinf kontstruktori hisoblanadi. Agar sinf o’z
konstruktoriga ega bo’lmasa, new operatori S# ko’rinishidagi o’z konstruktorini ishlatadi.
Demak, new operatori istalgan sinf ob’ektini ishlatish mumkin.
Xotira o’lchami cheklangani sababli, new operatori 2 ta ob’ektga yetarli xotira ajrata olmaydi
taxmini bor. Agar bu sodir bo’lsa, programma bajarishning keskin axvoli sodir byuo’ladi.
(Keskin axvollar bilan ishlashni 9 glavadan bilib olasiz). Bu kitob programmalari bilan ishlashda
xotira sig’imi yetmasligi bilan xavotirlanmasligingiz mumkin, lekin kelajakda o’z
programmalaringiz bilan ishlashda buni inobatga olishingiz kerak.
Professional javoblari
Savol. Nega oddiy tipdagi o’zgaruvchanliklarni yaratishda new operatorini ishlatish zarurligi
yo’Qoladi (int yoki float kabi)?
Javob. S# da oddiy tipdagi o’zgaruvchanlik o’zi o’z Qiymatini saQlaydi. Ushbu
o’zgaruvchanlikni saQlash uchun xotira programmani kompirlashda avtomatik ajratiladi va new
operatori orQali xotirani yaQQol ajratish zarur emas. Sso’lkali tipdagi o’zgaruvchanlik esa fakat
ob’ektga sso’lka saklaydi. Ob’ekt saQlash uchun xotira dinamik ajratiladi (programma bajarish
vaQtida).
Oddiy tipdagi o’zgaruvchanliklarni o’zgarishi cso’lkali tipdagi o’zgaruvchanlikka aylanishi
programma ishini sezilarli susaytirishi mumkin. Sso’lkali tipdagi o’zgaruvchanlik ishlatilganda
Qiymatlarga noto’g’ri Qaraladi, bu programma tezligini pasaytiradi.
Eksperiment uchun oddiy tipdagi o’zgaruvchanliklarni new operatori bilan ishlatish mumkin int i
q new int ();
Bunda int tipi uchun konstruktor chaQiriladi, bu i o’zgaruvchanga boshlang’ich 0 ni beradi.
Ammo ta’kidlash kerakki, bunda xotira dinamik ajratilmaydi. Ko’pchilik operatorlar oddiy
tipdagi o’zgaruvchanliklarga new operatorini ishlatishmaydi.
Destruktorlar va “axlat yig’ish”
Siz bilasizki, new operatorini ishlatganda ob’ektlar uchun xotira dinami ajratiladi.
Xotira sig’imi chegaralanganligi sababli, kerakli ob’ektni new operatori yordamida noto’g’ri
yaratish extimoli bo’ladi. Shuning uchun xotirani dinamik ajratish sxemasini asosiy komponenti
– bu ishlatilmayotgan ob’ektlardan xotirani bo’shatish va yangi ob’ektlar uchun belgilash. Ko’p
tillarda avval belgilangan xotirani bo’shatish programmasi Qo’lda bajariladi (masalan, SQQ da
xotirani bo’shatish uchun delete operatori ishlatiladi). S# buning uchun ancha effektliroQ
mexanizmga ega, bu “axlat yig’ish” deyiladi.
S# programmada ob’ektga muloQot bo’lmaganda, u ishlatilmaydigan ko’rinishda bo’ladi va
sistema programmistdan so’ramasdan avtomatik band bo’lgan va keyinchalik yangi ob’ektlarga
ajratish mumkin bo’lgan xotirani bo’shatadi.
Butun programma mobaynida “axlat yig’ish” ishlab turadi, bu operatsiyani boshlanishi uchun iki
shart – birinchidan, xotiradan bo’shatish mumkin bo’lgan ob’ektlarning mavjudligi, ikkinchidan,
ushbu operatsiyaning zarurligi. “Axlat yig’ish” protsessi bir muncha vaQt olgani sababli,
programmani bajarish sistemasi faQat zarur vaQtda ishlaydi, programmist bu Qachon amalga
oshishini bila olmaydi.
Destruktorlar
S# da “axlat yig’ish” operatsiyasi yordamida xotiradan ob’ektlarni yo’Qotishdan oldin
bajariladigan uslubni yaratish imkoniyati inobatga olingan. Bu uslub «destruktor” deyiladi va
ob’ektni xotiradan to’g’ri yo’Qotish uchun garantiya hisoblanadi. Masalan, destruktor yordamida
ishonch hosil Qilish mumkinki, Ushbu ob’ektga Qaratilgan fayl yopiladi. Destruktor Quyidagi
sintaksisga ega:
~slass-name()G’G’destruktor kodi
Bu yerda Class-name so’z birikmasi – sinf nomi. Destruktor konstruktor kabi chaQirtiriladi,
faQat destruktorda tilda (~) belgisi sinf nomidan oldin Qo’yiladi. Aytish lozimki, destruktor
aniQlanganda Qaytarilayotgan Qiymatning tipii ko’rsatilmaydi. Destruktorni Qo’shish uchun
sinfga kod Qo’shiladi (ya’ni destruktor sinfning oddiy bo’lagi hisoblanadi). Destruktor ichida
xotira Qaytgandan keyingi harakatlar belgilanadi. Destruktor o’zining sinf ob’ekti xotiradan
o’chishida doimo chaQiriladi.
Tushunish zarurki, destruktor «axlat yig’ish” operatsiyasi boshlanishidan oldin chaQiriladi. (Sinf
ob’ekti ko’rinish darajasidan uzoQda bo’lganda chaQirilmaydi. Bu bilan C# destruktorlari CQQ
destruktorlaridan farQ Qiladi). Bu destruktor kodi Qachon bajarilishini aniQlash mikoni
yo’Qligidan dalolat beradi. Undan tashQari, programma programma «axlat yig’ish” poeratsiyasi
boshlanishidan oldin ishni tugatishi mumkin, bu holda destruktor umuman chaQirilmaydi.
Proekt 4-2. Destruktorla ishini ko’rgazmasi.
Aytib o’tildiki, agar ob’ektlar programmada boshQa ishlatilmasa, ularni yo’Qotish majburiy
bo’lmaydi. “Axlat yig’ish” faQatgina effektiv bajarilishi mumkin bo’lgan holda bajariladi
(odatda bir nechta ob’ektlarga bir vaQtda). Shuning uchun destruktor ishini ko’rsatish uchun
ob’ektlarning ko’plab sonini yaratish va yo’Qotish zarur. Aynan shunga biz ushbu proektni
bag’ishlaymiz.
Ketma-ket instruksiya
1.
YAngi fayl yarating va uni Destruct.cs deb nomlang.
2.
Destruct sinfni pastda ko’rsatilgandek yarating:
Class Destruct
Int x;
Public Destruct (int i) (
x-i
G’G’ ob’ekt xotiradan yo’Qotilayotganda chaQiriladi
~Destruct () (
Console.WriteLine(Ob’ektdan xotirani yo’Qotish);
G’G’uslub srazu yo’Qotiladigan ob’ektni yaratadi.
Public void generator(int i) (
Destruct 0qnew Destruct (i);
Konstruktor o’ziga argument sifatida o’tkaziladigan x Qiymatli o’zgaruvchanni o’zlashtiradi.
Ushbu programmada destruktor o’zgaruvchan x yordamida ekran yo’Qotiladigan ob’ektning
nomerini beradi. Alohida Destruct ob’ektini yaratadigan va shu zaxoti yo’Qotadigan generator ()
uslubiga ahamiyat bering. Qo’llanmaning keyingi punktida Qanday bajarilishini ko’rasiz.
3.
DestructDemo sinfini yarating:
Class DestructDemo:
Public static void Main () {
Int count;
Destruct ob – new Destruct (0);
G’* so’ngra for sikli yordamida ob’ektlarning ko’p miQdori yaratiladi. Bo’sh xotiraning barchasi
ishlatilgandan so’ng «axlat yig’ish” operatsiyasi amalga oshiriladi. Buning uchun kearkli
ob’ektlar soni kompyuter xotirasi sig’imiga bog’liQ, shuning uchun siklini shartli ravishda
ko’rsatayotgan son ko’paytiriladi (sikl o’tish miQdori) *G’
for (count I; count – 100000’ count QQ)
ob.generator(count);
}
}
Boshida eshbu sinfda ob Destruct ob’ekti yaratiladi. So’ngra ushbu ob’ekt va generator uslubi
yordamida 100000 ta ob’ekt yaratiladi. Natijada programma bajarilishini ayrim etapida
faQatgina yaratilmay, balki yo’Qotilib ham turiladi, shunda turli etaplarda “axlat yig’ish” amalga
oshib turadi. Qachon va Qancha tez ushbu bajarilishi bir necha faktorlarga bog’liQ – bo’sh
xotiraning boshlang’ich sig’imi, operatsion sistemaning tipi va boshQa. Lekin ma’lum vaQtdan
so’ng ekranda destruktor tomonidan xabarlar paydo bo’ladi. Agar bunday xabarlar chiQmasa,
yaratilayotgan ob’ektlarni for siklidagi count o’zgaruvchilar yo’li bilan oshirish kerak.
4.
Quyida DextructDemo.cs programmasi ketma-ketligi ko’rsatilgan:
G’*
proekt 4-2.
Bu programmada destruktor ishi ko’rsatiladi.
G’*
using system;
class Destruct {
public int x;
public Destruct (int i) {
x-i
}
G’G’Xotiradan ob’ekt yo’Qotilganda chaQiriladi.
~Destruct () {
Console.WriteLine(“Destructing” Q x);
}
G’G’uslub srazu tozalanadigan ob’ektni yaratadi.
Public void generator(int i) (
Destruct 0qnew Destruct (i);
}
}
classDestructDemo{
public static void Main () {
int count;
Destruct ob – new Destruct (0);
G’* so’ngra for sikli yordamida ob’ektlarning ko’p miQdori yaratiladi. Bo’sh xotiraning barchasi
ishlatilgandan so’ng «axlat yig’ish” operatsiyasi amalga oshiriladi. Buning uchun kearkli
ob’ektlar soni kompyuter xotirasi sig’imiga bog’liQ, shuning uchun siklini shartli ravishda
ko’rsatayotgan son ko’paytiriladi (sikl o’tish miQdori)
*G’
for (count I; count – 100000’ count QQ)
ob.generator(count);
}
this kalit so’zi
Ushbu glava oxirida this asosiy so’zini ishlatilishini ko’rib chiQamiz. Uslub chaQirilganda unga
avtomatik ravishda chaQirilayotgan ob’ektga sso’lka sifatida noaniQ argument beriladi (ya’ni
uslub ishlaydigan ob’ektga nisbatan). Bu ko’rsatma this deyiladi. This ko’rsatmasi Qanday
ishlashini tushunish uchun Pwr sinfi Qo’llaniladigan programmani ko’ramiz.
Using system
Class Pwr {
Public double b;
Public int e;
Public double val;
Public Pwr (double num, int exp) {
b – num;
e – exp;
val – 1;
of (expqq0) return;
for( ; exp>0; exp--) val – val * b;
public double get_pwr () {
return val;
class DemoPwr {
public static void Main () {
Pwr x – new Pwr(4.0, 2)
Pwr y – new Pwr(2.5, 1)
Pwr z – new Pwr(5.7, 0);
Console.WriteLine (x.b. Q “ B “ Q x.e. Q “-y stepeni – “ Q x.get_pwr());
Console.WriteLine (y.b. Q “ B “ Q y.e. Q “-y stepeni – “ Q y.get_pwr());
Console.WriteLine (z.b. Q “ B “ Q z.e. Q “-y stepeni – “ Q .get_pwr());
Bilasizki, uslubda ichida boshQa sinf vakillariga ob’ekt yoki nomi bilan amalga oshiriladi.
Shuning uchun get_pwr uslubi ichida
return val;
operatori bajarilganda chaQirilayotgan ob’ekt bilan bog’langan val o’zgaruvchan nusxasi
chaQiriladi. Lekin shu operatorni Quyidagicha yozish mumkin:
return this.val;
Bu yerda this sso’lkasi get_pwr (; uslubi chaQirgan ob’ektga ko’rsatadi. Demak this val
o’zgaruvchan ushbu ob’ektda val o’zgaruvchanning nusxasi hisoblanadi. Masalan, get_pwr ()
uslubi x ob’ektga nisbatan chaQirilgan bo’lsa, unda this sso’lkasi ilgarigi operatorda ob’ekt x ni
ko’rsatadi. Aytish mumkinki, operatorni this so’zini ishlatmasdan yozish yozuvning QisQa
formasi hisoblanadi.
Quyida pwr ni barcha sinfi this kalit so’zi bilan ko’rsatilgan:
using system;
class pwr {
public double b;
public int e;
public double val;
public Pwr(double num, int exp) {
this.b – num;
this.e – exp;
this.val – 1;
if(exp—0) return;
for( ; exp0; exp--) this.val q this.val this.b;
}
public double get_pwr() {
return this.val;
}
}
Hech Qanday yaxshi programmist C# tilida Pwr sinfini bunday yozmaydi, chunki bu hech
Qanday ustunlik bermaydi. Lekin ayrim hollarda this sso’lkasi foydali bo’lishi mumkin.
Masalan, C# sintaksisi o’zgaruvchan va ularnig nusxalari uchun bir xil nomni ishlatishni
imkonini beradi. Bu sodir bo’lganda, lokal nom o’zgaruvchan nusxasini berkitadi va unga yo’lni
faQatgina this sso’lkasi orQali topsa bo’ladi. Masalan, Quyida keltirilgan Pwr () konstruktori
sintaksik bor hisoblanadi, lekin bu stilni ishlatish tavsiya etilmaydi.
Public Pwr(double b, int e) {
This.b – b;
This.e – e;
Val – 1;
if(e- -0) return;
for(; e0; e- -) val – val * b;
}
Ushbu versiyada Pwr() konstruktori parametrlar nomi va nusxalar nomi bir xil, shuning uchun
o’zgaruvchanlar berkitiladi. Agar siz this sso’lkasini ishlatayotgan bo’lsangiz o’zgaruvchan
nusxasini “ochishiz” mumkin.
Kontrol savollar
1.
Sinf va ob’ektning farQi nimada?
2.
Sinf Qanday aniQlanadi?
3.
Har bir ob’ekt nimaning nusxaisga ega bo’ladi?
4.
Ikkita alohida operatorni ishlatgan holda Mycounter sinfidagi counter nomli ob’ektni
Qanday chaQirish mumkin.
5.
double a Qiymatini Qaytaruvchi va ikkita a va b parametrlari bo’lgan myMeth uslubini
aniQlashni yozing.
6.
Uslub Qiymatni Qaytarsa uslubdan boshQaruv kelib chiQadimi?
7.
Kontsruktor Qanday nomga ega?
8.
new operatori Qanday funksiyani bajaradi?
9.
“axlat yig’ish” bu nima? Bu operatsiya Qanday bajariladi? Destruktor bu nima?
10.
this kalit so’zini ma’nosini tushuntirib bering?
Glava 5. Ma’lumotlar xillari va operator haQida
Massivlar
string operatorlari
foreach sikli
Operator?
Bu glavada C# operatori va ma’lumotlar tipiga Qaytish uchun string tipi massivlar va
operatorlarni ko’rib chiQamiz, hamda foreach sikli haQida gapiramiz.
Massivo’
Massiv – bu bir xildagi o’zgaruvchanlarning kolleksiyasi. Massivga Qaratilganda shu tipning
Qiymati berilgan elementning nomi va indeksi ko’rsatiladi. Massivlar ham bir o’lchamli ham
ko’po’lchamli bo’lishi mumkin, ko’pincha biro’lchamlilar ishlatiladi. Massivlar ko’p masalalarni
xal etishga yordam beradi, chunki bir tipdagi o’zgaruvchanga Qulay muhit yaratiladi. Masalan,
siz massivni oy davomida kunlik o’rtacha harorat yoki kursdoshlar haQida ma’lumot va boshQa
ma’lumotlar uchun ishlatishingiz mumkin.
Massivdagi ma’lumotlar shunday tashkillashtirilganki, ular bilan oson ishlash mumkin, aynan
shunda massivning asosiy tarafi ko’rinadi. Masalan, massiv abiturientning baholari haQida
axborot saQlasa, imtihon topshiruvchining o’rtacha balini hisoblash mumkin. Bundan tashQari,
bu ma’lumotlar oson ajratiladi.
C# da massivlarni boshQa programmalarning tillariga o’xshab ishlatish mumkin, faQat bitta
yaxshi tomoni bor. Bu shundan iboratki, da massivlar ob’ekt sifatida ko’riladi, shuning uchun
ushbu kitobda avval ob’ektlar so’ngra massivlar ko’riladi. Massivlarni bunday ishlatilishining
sababi C# -programmalarda Qo’shimcha imkoniyatlar paydo bo’ladi, masalan, “axlat yig’ish”
jarayonida ishlatilmaydigan massivlar xotiradan tozalanadi.
Bir o’lchamli massivlar
Biro’lchamli massiv – bu bir turdagi o’lchamlar ro’yxati. Programmirovaniyada bu ro’yxat teztez uchrab turadi. Masalan, biro’lchamli massivni aktiv ishlatuvchilarning schetlaridagi
nomerlarni saQlashga yoki basketbol komandasining Quyidagi reytingini saQlashga ishlatiladi.
Bir o’lchamli massivni ishlatish uchun Quyidagi sintaksis ishlatiladi:
type: } array-name q new type[size];
Bu yerda type so’zi massivni turini ko’rsatadi, ya’ni massiv tashkil topgan xar bir elementning
ma’lumotlar turini. Massiv elementlaridan keyingi kvadrat Qovuslarga axamiyat bering. Bu
Qovuslar yordamida biro’lchamli massiv ajratiladi 9bu bobda ikio’lchamli massiv Qanday
ajratilishi ko’rsatiladi). Masivga joylashtirilishi mumkin bo’lgan elementlar soni size kattaligi
bilan o’lchanadi. Massivlar ob’ektlar sifatida tarQalgani sababli massiv yaratish protsessii iki
etapdan iborat. Birinchi etapda masiv nomi ma’lum Qilinadi – sso’lkali o’zgaruvchan turi.
Ikinchi etapda massivga xotira ajratiladi va xotira massividagi o’zgaruvchanga sso’lka Qo’yiladi.
YA’ni C# da new operatori yordamida massivga xotira dinamik ajratiladi.
IZOH
Agar sizda S yoki SQQ da programmalashtirish tajribasi bo’lsa, unda C# da masivni chaQirishga
axamiyat Bering. AniQrog’i, C# da kvadrat Qovuslar massiv nomini eemas, tipini ko’rsatadigan
kalit so’zdan keyin Qo’yiladi.
Keyingi kodli Qator 10 ta elementdan iborat int tipidagi massivni yaratadi va unga sso’lka
sample tipidagi o’zgaruvchan hisoblanadi:
int[] sample q new int[10];
Massiv ob’ekt kabi chaQiriladi. sample o’zgaruvchani xotiradagi adresga new operatori orQali
ajratilgan sso’lkani saQlaydi. int tipidagi 10 ta elementni saQlash uchun xotira yetarli.
Massivni chaQirish (xuddi ob’ektni chaQirish kabi) ikki operator yordamida bajarish mumkin.
Masalan,
int[] sample;
sample q new int[10];
Bu holda sample massivi o’zgaruvchani Qandaydir fizik ob’ektga Qaratilmaydi. FaQatgina
ikkinchi operator bajarilgandan so’ng o’zgaruvchandan massivga Qaratiladi.
Massivning alohida elementiga dostup indeks yordamida bajariladi. Bu yordamida elementning
pozitsiyasi massiv ichida ko’rsatiladi. Massivning birinchi elementi C# da nol indeksga ega.
sample massivi 10 ta elementdan tashkil topganligi sababli, bu massiv elementlari indeksi
Qiymati 0 bilan 9 orasida joylashadi. Massivni indeksatsiyasi uchun kvadrat Qovuslarda
elementlar sonini ko’rsatish zarur. Shuning bilan, sample massivining birinchi elementi
sample[0], oxirgisi esa sample[9] ko’rinishda ko’rsatiladi. Masalan, Quyida ko’rsatilgan
programmada sample massiviga 0 dan 9 gacha bo’lgan Qiymatlar joylashtiriladi.
G’G’ programmada biro’lchamli massivni ishlatish ko’rsatilmoQda.
Using system;
Class ArrayDemo {
Int[} sample – new int[10];
Int I;
For(i-0; i
Sample[i] – I;
For(i-0; i
Console.WriteLine(“sample” elementiga [ “ Q I Q “ ] Qiymati berilgan: “ Q sample[i]);
}
}
Natijada programma ishlash jarayonida Quyidagi 10 Qator ko’rsatiladi:
sample [0] elementiga 0 Qiymat berilgan;
sample [1] elementiga 1 Qiymat berilgan;
sample [2] elementiga 2 Qiymat berilgan;
sample [3] elementiga 3 Qiymat berilgan;
sample [4] elementiga 4 Qiymat berilgan;
sample [5] elementiga 5 Qiymat berilgan;
sample [6] elementiga 6 Qiymat berilgan;
sample [7] elementiga 7 Qiymat berilgan;
sample [8] elementiga 8 Qiymat berilgan;
sample [9] elementiga 9 Qiymat berilgan.
sample massivi sxematik Quyidagi ko’rinishga ega:
0
1
2
3
4
5
6
7
8
9
sample
[0]
sample
[1]
sample
[2]
sample
[3]
sample
[4]
sample
[5]
sample
[6]
sample
[7]
sample
[8]
sample
[9]
Bir turdagi o’zgaruvchanlarning kata miQdori bilan ishlashga Qulay bo’lgani uchun massivlar
programmalashtirishda keng Qo’llaniladi. Masalan, Quyida ko’rsatilgan for siklidagi nums
massividagi elementlarni ishlash programmasi yordamida ushbu masivning maksimal va
minimal elementlar Qiymatini topish mumkin.
G’G’ programma massiv elementlar Qiymatining maksimal va minimal Qiymatlarini topadi.
Using system;
Class MinMax {
Public static void Main(} {
Int {] nums q new int[10];
Int min, max;
nums[0] – 99;
nums[1] – 10;
nums[2] – 100123;
nums[3] – 18;
nums[4] – 978;
nums[5] – 5623;
nums[6] – 463;
nums[7] – 9;
nums[8] – 287;
nums[9] – 49;
min q max – nums[0];
for(int iq1; I < 10; iQQ) {
if(nums[i] < min) min q nums[i];
if(nums[i] < max) max q nums[i];
}
Console.WriteLine(“Minimal Qiymat: “ Q min Q “,“ Q max Q “);
}
Bu programmani bajarish natijasi Quyidagicha:
Minimal Qiymat: -978, maksimal Qiymat: 100123
Massiv initsializatsiyasi
Avvalgi programmada nums massiv elementlariga Qiymat Qo’lda 10 ta operator yordamida
Qilingan edi. Bu operatsiya bajarishni ancha effektiv yo’li mavjud. Masivni initsializatsiyalashni
uni yaratilishi bilan boshlash mumkin. Biro’lchamlik massivni umumiy sintaksis
initsializatsiyasi Quyidagicha:
type[} array-nameq{vall, val2, … , valN;
Bu yerda boshlang’ich Qiymatlar vall dan valN gacha ko’rsatilgan. Massiv elementlariga
Qiymatlar navbat bilan chapdan o’ngga 0 indeksli elementdan boshlab beriladi. C# da massivga
avtomatik xotira sig’imi beriladi, bunda new operatorini yaQol ishlatish zarurligi tug’ilmaydi.
Quyida MinMax programmasini ancha Qulay yozish uslubi ko’rsatilgan:
Using system;
Class MinMax {
Public static void Main() (
Int[] nums q { 99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49 );
Int min, max;
Minqmax – nums[0];
For(int iq1; i < 10; iQQ) {
If(nums[i] < min) min – nums[i];
If(nums[i] < max) max – nums[i];
}
Console.WriteLine(“Minimal Qiymat: “ Q min Q “,“ Q max Q “);
}
}
Bunda zaruriyat bo’lmasa ham, eksperiment sifatida massiv initsializatsiyasi uchun new
operatorini ishlatishiz mumkin. Masalan, nums initsializatsiyasi uslubi Qoidaga Qarshilik
Qilmaydi, new operatori esa shat emas.
Int[] nums q new int[] { 99, -10, 100123, 18, -978,
5623, 463, -9, 287, 49;;
Bu holda nums massiv o’zgaruvchani birinchi operatorda chaQiriladi, ikinchisida esa
initsializatsiyalanadi.
Indekslar chegara Qiymatlari ustidan QattiQ nazorat
C# da masiv elementiga murojat etish kuchli nazoratda bo’ladi. Massiv indeks Qiymati
chegarasidan oshmaydigan indeks ko’rsatilishi lozim, aksi holda programma bajarilishda xatoga
yo’l Qo’yiladi. Bunga ishonch hosil Qilish uchun ataylab mavjud bo’lmagan indeks ko’rsatilgan
keyingi programmani tekshirib ko’ring (ya’ni mavjud bo’lmagan elementga murojat etish
harakati amalga oshiriladi).
using system
class ArrayErr {
Public static void Main() (
Int[] sample – new int[10];
Int i;
for siklini shartli ko’rinishida i o’zgaruvchani sample massivi indeks Qiymati chegarasidan
oshadigan indeksni oladi.
for {i – 0; i < 100; i - iQ1)
sample[i] – 1;
}
}
Programma bajarilishining ma’lum etapida I o’zgaruvchaniga 10 Qiymat beriladi. 10 indeksli
elementga murojat etish harakatida programma yopiladi va IndexOutOfRangeException ob’ekti
yopiladi.
DaQiQali amaliy ish
1.
Massiv elementiga nima orQali muroja etiladi?
2.
10 ta elementdan iborat char massivini Qanday chaQirish mumkin?
3.
C# programma bajarilishi davomida massiv indekslarining chegara Qiymatlarini
bajarilmasligi to’g’rimi?
Proekt 5-1. Massiv sortirovkasi
Biro’lchamli massivda ma’lumotlar indekslangan to’g’ri ro’yxatda joylashgani sababli, ularni
sortirovkalash oson. Ularning ichida tez sortirovkalash algoritmi, havochali algoritm va Shell
uslubi yordamidagi algoritm sortirovkasini ajratish mumkin. Eng sosn, soda va tushunarli – bu
havochali algoritm hisoblanadi. Uncha effektiv bo’lmasa ham (katta massivlarni sortirovkalash
uchun to’g’ri kelmaydi), lekin kata bo’lmagan massivlarga ishlatilishi mumkin.
Qo’llash yo’riQnomasi
1.
Fayl yarating va uni Bubble.cs deb nomlang.
2.
Havochali algoritm sortirovkasi o’z nomiga ishining prinsipi bilan mos ega bo’ldi. Uni
yaxshilab ko’rib chiQamiz. Tasavvur Qilamizki, 20 ta elementdan iborat massiv mavjud,
ularni o’sishi bo’yicha sortirovkalash kerak. 2ta yonida turuvchi Qiymatlar solishtiriladi.
Agar ikkinchi elementning Qiymati birinchisinikidan kam bo’lsa, unda ayrim oraliQ
o’tkazuvchanga birinchisining nomi beriladi, birinchisiga esa oraliQning Qiymati
beriladi. Aytish mumkinki, elementlar joy almashadi, kam Qiymatli element massivning
chap chegarasiga o’tadi. Buni havoning suvda harakatlanishiga taQQoslash mumkin –
chuQurlikdan tepaga, shuning uchun algoritm shunday nomlangan. 20 ta elementdan
iborat massivda barcha Qo’shni elementlarni taQQoslash uchun (birinchini ikkinchi
bilan, ikinchini uchinchi bilan va h.k.) 20 – 1 q 19 taQQoslashni bajarish zarur, bunda
eng kichik Qiymat so’nggi elementda (yigirmanchida) Qoladigan bo’lsa, uning massiv
boshiga harakatlanishi uchun 19 ta harkatni bajarish zarur. YA’ni ikkita siklni
tashkillashtirish zarur – tashQi va ichki, har biri 19 marta bajarilishi zarur.
Pastda havochali algoritmi yadrosini tashkil etuvchi kod fragmenti keltirilgan. Elementlar
sortirovkasi bajariladigan massiv nums deyiladi.
G’G’ havochali algoritm sortirovkasi kodi
for (aq1; a < size; aQQ)
for(bqsize-1; b > q a; b - -) {
if(nums[b-1] > nums[b]) { G’G’ Agar avvalgi element Qiymati keyingisidan katta bo’lsa,
ular “joylari bilan almashadi”.G’G’
t q nums[b-1] – nums[b];
nums[b] – t;
}
}
Ushbu abzatsdagi material yaxshi o’zlashtirilishi uchun yana bir bor havochali algoritm
prinsipini Qaytarib o’tamiz. Algoritm 2 ta for sikli asosida Qurilgan. Bir biriga yaQin turgan
elementlar Qiymati ichki siklda tekshiriladi. O’sib borish asosida turmagan elementlar parasi
topilganda, ular joy bilan almashadi.Har bir o’tkazilganda kichik Qiymatli elementlar o’zining
Qiymatiga yarasha harakatlanadi. TashQi sikl bu protsesni massivdagi barcha elementlar
sortirovkalanishigacha Qaytaradi.
3.
Quyida Bubble programmasining barcha kodi keltirilgan.
G’*
Proekt 5-1.
Programmada massiv elementlarining havochali algoritm sortirovkasi ko’rsatilgan.
*G’
using System;
class Bubble {
public static void Main () {
int[] nums – { 99,-10, 100123, 18, -978,
5623, 463, -9, 287, 49 }
int a, d, t;
int size;
size q 10; G’G’ Massiv elementlari soni.
G’G’ Birlamchi massiv elementlar Qiymatini ko’rinishi.
Console.Write(“Birlamchi massiv elementlar Qiymati: G’n”);
for(int iq0; i < size; iQQ)
Console.WriteLine();
G’G’ Bu havochali algorim sortirovkasi kodi.
for(a-I; a < size; aQQ)
for(bqsize-1; b>-a; b—{
if(nums[b-1] > nums[b] { G’G’ Agar avvalgi element Qiymati keyingisidan katta bo’lsa,
ular “joylari bilan almashadi”.G’G’
t q nums[b-1] – nums[b];
nums[b] q t;
}
}
G’G’ Sortirovkalangan massiv elementlar Qiymatini ko’rinishi.
Console.Write(“Sortirovkalangan massiv elementlar Qiymati: G’n”);
for(int iq0; i < size; iQQ)
Console.WriteLine(“ “ Q nums[i]);
Console.WriteLine();
}
}
Quyida ushbu programani bajarish natijasi ko’rsatilgan.
Birlamchi massiv elementlar Qiymati:
99, -10, 100123, 18, -978, 5623, 463, -9, 287, 49
Sortirovkalangan massiv elementlar Qiymati:
-978, -10, -9, 18, 49, 99, 287, 463, 5623, 100213
kata bo’lmagan massivlar uchun havochali algoritm orQali ma’lumotlar sortirovkasi to’g’ri
kelsa, katta massivlar bilan ishlashga mo’ljallanmagan. Tez sortirovkalash algoritmi eng yaxshi
universal algoritm hisoblanadi. Lekin u C# ning sizga noma’lum bo’lgan tiliga asoslangan, bu
algoritm haQida 6 bobda to’xtalamiz.
Ko’po’lchamli massivlar
Biro’lchamli massivlar programirovaniyada eng ko’p tarQalgan hisoblanadi, lekin
ko’po’lchamlilari ham unchalik kam uchramaydi. Ko’po’lchamli bo’lib iki yoki undan ko’p
shakllarga ega, alohida elementiga yo’l esa iki va ko’p indekslarni ko’rsatish bilan amalga
oshiriladigan masivlarga aytiladi.
Ikkio’lchamli massivlar
Ko’po’lchamlik massivlarni ichida eng soddasi ikkio’lchamli massiv hisoblanadi. Unda konkret
element joylashuvi ikki indeks bilan aniQlanadi. Ikkio’lchamli massivni axborot jadvali sifatida
ko’rish mumkin, unda bir indeks Qator nomeri, ikinchisi ustun nomerini ko’rsatadi.
Ikkio’lchamli 10x20 katalikdagi table massivi Quyidagicha chaQiriladi:
Int[,] table – new int[10, 20];
Axamit Bering, ushbu massiv chaQirilganda masivning ikki xil o’lchami vergul bilan ajratilgan.
Operatorning birinchi Qismida kvadrat skobkalar ichidagi vergul yordamida ikio’lchamli
massivga sso’lkali o’zgaruvchan yaratiladi. New operatori yordamida massivga xotira ajratish
masivni ikinchi Qismini bajarishda chaQiriladi:
New int[10, 20]
Bunda o’lchami 10, 20 bo’lgan massiv yaratiladi. Axamiyat beringki Qiymatlar o’lchami vergul
bilan ajratilgan. Masalan, table[3, 5] massivi elementiga 10 Qiymatni berish uchun Quyidagi
operatorni ishlatish zarur:
table[3, 5]q10;
Quyida elementlariga 1 dan 12 gacha bo’lgan Qiymalar berilgan ikkio’lchamli massiv
programmasi ko’rsatilgan va bu Qiymatlar ekranga iQarilgan.
G’G’ programmada ikkio’lchamli massiv ishlatilishi ko’rsatilgan.
Using system;
Class Twod {
public static void Main () {
int t, i;
int[,] table – new int [3, 4);
for(t-0; t < 3; QQt);
for(iq0; i < 4; QQi) {
table[t,i]q(t*4)QiQ1;
Console.Write(table[t, i] Q “ “);
}
Console.WriteLine();
}
}
}
Ushbu programmada table {0, 0}elementi 1 Qiymatga ega, table [0, 1] – 2ga, table[0, 2] – 3 ga
va h.k. table[2, 3] elementi 12 ga ega bo’ladi. Quyida massivni sxematik ko’rinishi berilgan.
Izoh
Agar sizda C, CQQ Java programmalarida ishlash tajribasi bo’lsa, axamiyat berinki, C# da
ko’po’lchamli massivlar elementlariga yo’l ushbu tilarga mos bo’lmagan holda chaQiriladi.
Ularda massiv va indekslarning har bir o’lchami alohida kvadrat Qovuslarda ko’rsatiladi, C# da
esa ko’rsatilgan o’lchamlar vergul bilan ajratiladi.
Ikkitadan ko’p o’lchamga ega bo’lgan massivlar
C# da ikkidan ko’p o’lchamga ega bo’lgan massivlarni ishlatish mumkin, Quyida ko’po’lchamli
massivning umumiy sintaksisi berilgan:
type[,….,] name – new type[size1, size2,….,sizeN];
Masalan, keyingi operator bajarilishida butun sonli 3 o’lchamli 4x10x3 o’lchamli massiv
yaratiladi:
int[,,]multidimqnew int[4, 10, 3];
multidim[2, 4, 1] massiv elementiga 100 Qiymatni berish uchun, Quyidagi operatorni bajarish
zarur:
multidim[2, 4, 1] q 100;
Ko’po’lchamli masivlari initsializatsiyasi
Figurali Qovuslarga joylashtirilgan alohida blokdagi Qiymatlar ro’yxatini Qo’ygan holda ko’p
o’lchamli massivni initsializatsiyalash mumkin.
type[,] array_nameQ;
{val, val, val,... val}
{val, val, val,... val}
{
{
{
{val, val, val,... val},
};
Bu yerda val so’zi berilayotgan Qimatni ajratadi. Har bir ichki blok Qatordagi element Qiymatini
beradi. Qator ichida birinchi ko’rsatilgan Qiymat Qatorning 0-chi elementida saQlanadi, ikkinchi
Qiymat – birinchi elementda va h.k. Axamiyat bering, Qiymatlar saQlovchi bloklar vergul bilan
ajratilgan, blokni yopuvchi figurali skobkadan keyin esa ; keladi.
Keltirilgan Quyidagi programmada sqrs masivi initsializatsiyalangan, unda har bir elementga 110 oraliQdagi Qiymat va uning kvadrati beriladi.
Using sytem;
Class Squares {
Public static void Main() {
Int[,] sqrsq{
{1, 1},
{3, 9},
{4, 16},
{5, 25},
{6, 36},
{7, 49},
{8, 64},
{9, 81},
{10, 100}
};
int i, j;
for(iq0; Ii < 10; iQQ) {
for(j-0; j < 2; jQQ)
Console.Write(sqrs[i,j] Q “ “);
Console.WriteLine();
}
}
}
Quyida ushbu programmani bajarish ko’rsatilgan.
1.
1
2.
4
3.
9
4.
16
5.
25
6.
36
7.
49
8.
64
9.
81
10.
100
Tekkislanmagan massivlar
Avvalgi programmada ikkio’lchamli massiv, ya’ni to’g’riburchakli massiv yaratilishi
ko’rsatilgan edi. Jadvaliy ko’rinishda to’g’riburchakli massiv – bu ikkio’lchamlik massiv, unda
Qatorla uzunligi bir xil. Bundan tashQari, C# da ikkio’lchamli massivning maxsus turini yaratish
mumkin, u notekis massiv hisoblanadi. Tekislanmagan massiv – bu tashQi massiv, turli
o’lchamlardagi massivlardan tashkil topgan. Notekis massivni turli uzunlikdagi Qatorlarni
tashkil Qiluvchi jadval yaratish uchun ishlatish mumkin.
Notekis massivlar chaQirtirilganda har bir o’lchamni alohida ko’rsatish uchun alohida Qovuslar
juftligi ishlatiladi. Masalan ikkio’lchamli notekis massiv Quyidagicha chaQiriladi:
Type[][] array-nameqnew type[size][];
Bu yerda Size so’zi massivdagi Qatorlar sonini ko’rsatadi. Qatorlar o’lchami ko’rsatilmaydi va
ularga xotira ajratilmaydi. Har bir Qatorga alohida new operatorini ishlatish zarur. Bunday
texnologiya turli uzunlikdagi Qatorlarni aniQlashga imkon beradi. Masalan, keyingi kod bilan
jagged massivi e’lon Qilinganda xotira faQat tashQi massivga ajratiladi, so’ng esa 3 ta operator
bajarilganda xotira har bir ichki massivga ajratiladi:
int[] [] jagged – new int[3] [];
jagged[0] – new int [2];
jagged[1] – new int [3];
jagged[2] – new int [4];
Bu operatorlar ketma-ket bajarilgandan so’ng notekis massiv Quyidagicha ko’rinishga ega:
jagged[0] [0] jagged[0] [1]
jagged[1] [0] jagged[1] [1] jagged[1] [2]
jagged[2] [0] jagged[2] [1] jagged[2] [2] jagged[2] [3]
Bu sxemani ko’rib chiQQandan so’ng nima uchun notekis massiv bunday nom olganini ko’rasiz.
Notekis massiv yaratilganda, uning elementlariga yo’lni kvadrat skobkalardagi xar bir indeksni
ko’rsatgan holda topish mumkin. Masalan jagged[2] [1] masiviga 10 Qiymatni berish uchun
Quyidagi operatorni ishlaish zarur: jagged[2] [1]q10;
Eslatma: to’g’riburchakli massiv elementlariga yo’lni topish uchun yozuvning o’zgacha formasi
ishlatiladi.
Quyidagi programmada notekis ikkio’lchamli massiv ishlatilishi ko’rsatilgan. Massivda
aeroportda boish uchun marshrut taksidan foydalanadigan pasajirlar soni haQida ma’lumot
saQlanadi. Marshrut taksi xafta kunlari mobaynida bir xil bo’lmagan reyslar sodir etgani sababli
( 10 ta reys begim kunlari va 2 ta dam olish kunlari), ma’lumotlarni saQlash uchun notekis riders
masividan foydalanish mumkin. Axamiyat beringki, 2 chi o’lcham birlamchi 5 ta Qatorda 10
Qiymatga ega, Qolgan 2 ta Qatorga – 2.
using system{
public static void main() {
int[] [] riders – new int [7][];
riders [0] q new int[10];
riders [1] q new int[10];
riders [2] q new int[10];
riders [3] q new int[10];
riders [4] q new int[10];
riders [5] q new int[2];
riders [6] q new int[2];
int i, j;
G’G’Massiv elementlariga ayrim Qiymatlar beriladi.
For(i-0; I < 5; iQQ)
For(jq0; j < 10; jQQ)
Riders[i][j] q I Q j Q 10;
Length xossasining Qo’llanishi
S# da massivlar ob’ektlar sifatida amalga oshirilgan va bu massivlar bilan ishlashda muayyan
afzalliklarni beradi. Ulardan biri – Length xossasini Qo’llash imkoniyatidir. Har bir massiv
Length xossasi bilan assotsiatsiyalashish xususiyatiga ega. U massivlvrning maksimal
miQdordagi elementlari haQidagi axborotlarni o’z ichiga oladi (ya’ni, massivlarda (sinf nazarda
tutilgan) massivlarni uzunligi haQidagi axborotlarni Qamrab oluvchi joylar mavjud). Quyida
Length xossasini Qo’llash bo’yicha dastur ko’rsatilgan.
G’G’ Dasturda Length xossasini Qo’llash namoyish etiladi.
using System;
class LengthDemo {
public static void Main () {
int [] list q new int [10];
int [] nums q {1, 2, 3,};
int [] [] table q new int [3] []; G’G’ table tenglashmagan massivi.
G’G’ ichki massivlar uchun xotira ajratish.
table [0] q new int [] {1, 2, 3};
table [1] q new int [] {4, 5};
table [2] q new int [] {6, 7, 8, 9};
Console.WriteLine (“massiv uzunligi list q “ Q list.Length);
Console.WriteLine (“massiv uzunligi nums q “ Q nums.Length);
Console.WriteLine (“massiv uzunligi table q “ Q table.Length);
Console.WriteLine (“massiv uzunligi table [0] q “ Q table [0] .Length);
Console.WriteLine (“massiv uzunligi table [1] q “ Q table [1] .Length);
Console.WriteLine (“massiv uzunligi table [2] q “ Q table [2] .Length);
Console.WriteLine ();
G’G’ list massivini initsializatsiyalash uchun Length xossasini Qo’llash.
for (int iq0; i
list [i] q i * i;
Console.WriteLine (“list massivi elementlarining mazmuni:”);
G’G’ list massivi elementlari mazmunini ko’rsatish uchun Length xossasini Qo’llash.
for (int iq0; i
Console.Write (list [i] Q “”);
Console.WriteLine ();
}
}
Quyida bu dasturning bajarilish natijalari keltirilgan.
list massivining uzunligi q 10
nums massivining uzunligi q 3
table massivining uzunligi q 3
table [0] massivining uzunligi q 3
table [1] massivining uzunligi q 2
table [2] massivining uzunligi q 4
list massivi elementlarining mazmuni: 0 1 4 9 16 25 36 49 64 81
Length xossasini Qo’llashda asosiy e’tiborni ikki o’lchamli tenglashmagan table massiviga
Qaratish kerak. YUQorida aytganimizdek, ikki o’lchamli tenglashmagan massiv – bu massivlar
massividir. Shunday ekan, table.Length ifodasini Qo’llashda, biz table massivini tashkil etuvchi
(bu yerda miQdor 3 ga teng) massivlar miQdoriga ega bo’lamiz. table tashQi massividagi har bir
ichki massiv uzunligi mazmuniga ega bo’lish uchun Quyidagi ifodadan foydalanish zarur:
table [0].Length
Bu holda biz 0 indeksga tegishli bo’lgan ichki massiv uzunligi mazmuniga ega bo’lamiz.
LengthDemo sinfida for bosQichi shartli ifodada list.Length xossasi mazmuni Qo’llanilishiga
e’tiboringizni Qarating. Har bir massiv o’z uzunligi haQida Qancha ko’p axborot saQlasa, undan
ifodalarda foydalanish mumkin. Bu turli uzunlikdagi massivlar bilan ishlash mumkin bo’lgan
kodni yaratish imkonini beradi. Length xossasining mazmuni haQiQatda massivda
saQlanayotgan elementlar miQdori bilan umumiylikka ega emas. Length maydoni massiv
saQlash mumkin bo’lgan elementlar soni haQidagi axborotni o’z ichiga oladi.
Length xossasini Qo’llash massivlar bilan bo’ladigan ayrim operatsiyalarni samarasini oshirib,
ko’plab algoritmlarni ishlarini osonlashtiradi. Masalan, navbatdagi dasturda mazmunni bir
massivdan boshQasiga nusxa ko’chirishda Length xossasi massiv indekslari mazmunini
chegaradan tashQariga chiQish imkoniyatlarini kengaytirishda Qo’llaniladi (dasturni bajarish
vaQtida ayrim holatlarga olib kelishi mumkin):
G’G’Dasturda bir massivdan boshQasiga nusxa ko’chirishda Length xossasini Qo’llash
namoyish G’G’etiladi.
using System;
class ACopy {
public static void Main () {
int i;
int [] nums1 q new int [10];
int [] nums2 q new int [10];
for (iq0; nums1.Length; iQQ) nums1 [1]qi;
G’G’ nums1 massividan nums2 massiviga nusxa ko’chirish.
if (nums2.Length >q nums1.Length)
for (i q 0; i < nums2.Length; iQQ)
nums2 [i] q nums1 [i];
for (i q 0; i < nums2.Length; iQQ)
Console.Write (nums2 [i] Q “”);
}
}
Bu yerda Length xossasi ikkita funksiyani bajarilishining tuzilishida kalit bo’lib sanaladi.
Birinchidan, Length xossasi mazmuni nums2 massivining o’lchamlari nums1 massivining barcha
elementlarini unga ko’chirib o’tkazish imkoniyati bor yoki yo’Qligini tekshirib ko’rishda
Qo’llaniladi. Ikkinchidan, Length xossasi nusxa ko’chirishni amalga oshiradigan for sikli shartli
ifodasida Qo’llaniladi. Albatta, bu juda oddiy misol, ammo bunday texnologiya ancha murakkab
algoritmlarda ham Qo’llanilishi mumkin.
DaQiQali amaliyot
1.
Massivga sso’lka Qilinayotgan, bitta o’zgaruvchi sso’lka tipi mazmunini o’zlashtirishda,
xuddi shunday birinchi massivning o’zgartirilgan elementlarini ikkinchisiga ko’chirishni
tasdiQlash to’g’rimi?1
2.
Length xossasi o’zi bilan nimani ko’rsatadi?2
Loyiha 5-2. Queue sinfi
Qdemo.cs
Ma’lumki, ma’lumotlar strukturasi ma’lumotlarni tashkil Qilish usuli bo’yicha farQlanadi.
Ma’lumotlarning oddiyroQ strukturasi bo’lib, chiziQli ro’yxatni ko’rsatuvchi massiv sanaladi.
Massiv elementlarga dostup berish uchun elementning nomi va indeksi ko’rsatiladi. Massivlar
tez-tez stek (stacks) va navbat (queues) singari, nisbatan murakkab tuzilgan ma’lumotlar
strukturasi sifatida ham ishlatiladi. Stacks – bu FILO (first in, last out – “birinchi kirib, oxirida
chiQdi”) prinsipi bo’yicha elementlarga dostup berishni amalga oshiruvchi ro’yxat. Queues – bu
FIFO (first in, first out – “birinchi kirib, birinchi chiQdi”) prinsipi bo’yicha elementlarga dostup
berishni amalga oshiruvchi ro’yxat. Stekni tarelkalar taxlamiga o’xshatish mumkin, ya’ni eng
pastdagi tarelka eng oxirida ishlatiladi, navbatni esa bankdagi navbatga o’xshatish mumkin –
ya’ni, birinchi kelganga birinchi bo’lib xizmat ko’rsatiladi.
Steklar va navbatlar shunisi bilan Qulayki, ularda axborotlarni saQlash vositasi, shu axborotlarga
dostupni ta’minlovchi uslublar bilan birlashtirilgan. Shunday Qilib, steklar va navbatlar
ma’lumotlarni saQlash va chiQarishni ta’minlash dasturning yordamisiz ma’lumotlar strukturasi
bilan amalga oshiriladi va ma’lumotlarga dostup berish mexanizmlarini o’zida
mujassamlashtiradi. Bunday birlashtirish so’zsiz, sinf konstruksiyasiga muvofiQ keladi. Bu
loyida Queuening oddiy sinfiga asos solinadi.
Umuman navbatlar ikkita bazali metodni Qamrab olgan – put (joylashtirmoQ) va get
(chiQarmoQ). Put metodining har birini bajarishda, navbat oxirida turgan massiv elementi
(ya’ni, indeksga ega bo’lgan, navbatning joriy holatiga mos keluvchi) ayrim mazmunlarni
Qamrab oladi. Get metodining har birini bajarishda massiv elementlaridan, navbat boshida
turgani mazmun hisoblanadi. Element mazmuni faQat bir marta hisoblanishi mumkin. Agar
yangi mazmunni to’plash uchun erkin elementlar bo’lmasa va bo’sh deb hisoblansa, hamda
navbatdagi barcha elementlar mazmuni hisoblangan bo’lsa, navbat to’lgan bo’lib sanaladi.
Navbatning ikki asosiy xili mavjud – doirasimon va doirasimon bo’lmagan navbatlar.
Doirasimon navbatda mazmunlarni hisoblashda “bo’sh” elementlar takroran ishlatiladi (Bunda
elementlar “bo’shamaydi” – shunchaki algoritm bilan muvofiQ holda doirasimon navbat ishida
yangi mazmunlarni o’zlashtirishga “imkon” beriladi). Doirasimon bo’lmagan navbatda bu narsa
sodir bo’lmaydi, shuning uchun bu navbat oQibatda o’z elementlari indeks raQamlarini
belgilaydi. OddiyroQ bo’lishi uchun berilgan misolda biz doirasimon bo’lmagan navbatni
yaratamiz, ammo siz biroz harakat Qilib uni doirasimon navbatga aylantirishingiz mumkin.
1 Йўқ. Фақат ссылка ўзгартирилади.
2 Length – бу ҳар бир массивга тегишли хоссадир. У массивда сақланиши мумкин бўлган
элементлар миқдори ҳақидаги ахборотни ўз ичига олади.
http://hozir.org