7-mavzu: Ko‘rsatkichlar va dinamik xotira bilan ishlash

C++ dasturlash tilida interaktiv o‘quv sahifasi

← Barcha darslar
Darsning bajarilish holati: 0 / 6 bo‘lim

1.1. Ko‘rsatkich tushunchasi: manzil olish va murojaat

Kompyuter xotirasi – raqamlangan baytlar ketma-ketligi. Har bir baytning o‘z manzili bor. Dasturda e’lon qilingan har bir o‘zgaruvchi xotiradan joy egallaydi va shu joyning boshlang‘ich manzili o‘zgaruvchining manzili hisoblanadi.

Ko‘rsatkich (pointer) – qiymat sifatida boshqa o‘zgaruvchining manzilini saqlaydigan o‘zgaruvchi. U orqali o‘zgaruvchiga bilvosita murojaat qilish, dinamik xotira ajratish va funksiyalarga katta ma’lumotlarni nusxalamasdan uzatish mumkin.

Ikki asosiy operator

Operator Nomi Vazifasi
&x Manzil olish x o‘zgaruvchining xotiradagi manzilini qaytaradi.
*p Murojaat (dereference) p ko‘rsatayotgan manzildagi qiymatni beradi.
tur *nomi; // ko‘rsatkichni e’lon qilish int x = 10; int *p = &x; // p – x ning manzilini saqlaydi cout << *p; // 10 – p ko‘rsatgan joydagi qiymat *p = 20; // x = 20 bo‘ldi! int *q = nullptr; // hech narsani ko‘rsatmaydigan ko‘rsatkich
Eslatma: * belgisi ikki xil ma’noda ishlatiladi. E’londa (int *p) u “bu ko‘rsatkich” degani, ifodada (*p = 20) esa “ko‘rsatilgan joydagi qiymat” degani. Ko‘rsatkich turi u ko‘rsatadigan o‘zgaruvchi turiga mos bo‘lishi kerak: int* faqat int ni ko‘rsatadi.
🧭 Interaktiv: ko‘rsatkich xotirada
Misol 1: Manzil olish va ko‘rsatkich orqali murojaat
Natija:
Natija bu yerda ko‘rsatiladi...
E’tibor bering: manzillar (0x7ffd...) har safar dastur ishga tushganda boshqacha chiqadi – operatsion tizim xotirani har gal turli joydan ajratadi. 64 bitli tizimda istalgan ko‘rsatkich hajmi 8 bayt.
Misol 2: nullptr, qayta yo‘naltirish va turli turdagi ko‘rsatkichlar
Natija:
Natija bu yerda ko‘rsatiladi...

1-bo‘lim nazorati

int x = 10; int *p = &x; *p = 20; – shu kod bajarilgandan keyin x nimaga teng?

1.2. Ko‘rsatkichlar arifmetikasi va massivlar

Massiv nomi – uning birinchi elementining manzili: a va &a[0] bir xil. Shu sababli massivni ko‘rsatkich orqali aylanib chiqish mumkin.

Ko‘rsatkichga butun son qo‘shilganda manzil baytlarda emas, elementlarda siljiydi: p + 1 keyingi elementni ko‘rsatadi, ya’ni manzil sizeof(tur) baytga oshadi.

Ifoda Ma’nosi
p + i i-elementning manzili (&a[i])
*(p + i) i-element qiymati – a[i] bilan aynan bir xil
p++, p-- Keyingi / oldingi elementga o‘tish
q - p Ikki ko‘rsatkich orasidagi elementlar soni
p < q Ko‘rsatkichlarni solishtirish (bitta massiv ichida)
➕ Interaktiv: ko‘rsatkich massiv bo‘ylab harakatlanadi
Misol 3: a[i] va *(p + i) – bir xil narsa
Natija:
Natija bu yerda ko‘rsatiladi...
Misol 4: Massivni faqat ko‘rsatkichlar bilan qayta ishlash
Kiruvchi ma’lumotlar (stdin): n, keyin n ta element
Natija:
Natija bu yerda ko‘rsatiladi...

2-bo‘lim nazorati

int a[5]; int *p = a; bo‘lsa, *(p + 3) ifodasi nimani bildiradi?

1.3. Ko‘rsatkichlar, havolalar va funksiyalar

Funksiyaga argument odatda qiymat bo‘yicha uzatiladi: funksiya o‘zgaruvchining nusxasi bilan ishlaydi va asl o‘zgaruvchi o‘zgarmaydi. Funksiya chaqiruvchi tomondagi o‘zgaruvchini o‘zgartirishi uchun unga o‘zgaruvchining manzili (ko‘rsatkich) yoki havolasi (reference, &) uzatiladi.

Uzatish usuli E’lon Chaqiruv Asl o‘zgaruvchi o‘zgaradimi?
Qiymat bo‘yicha void f(int x) f(a) Yo‘q
Ko‘rsatkich orqali void f(int *x) f(&a) Ha, *x orqali
Havola orqali void f(int &x) f(a) Ha, x – a ning taxallusi
🔄 Interaktiv: swap() funksiyasi stekda qanday ishlaydi?
Misol 5: Uch xil swap – farqini ko‘ring
Natija:
Natija bu yerda ko‘rsatiladi...

const va ko‘rsatkichlar

E’lon *p = ... (qiymatni o‘zgartirish) p = ... (boshqa joyni ko‘rsatish)
int *p ✓ mumkin ✓ mumkin
const int *p ✗ mumkin emas ✓ mumkin
int *const p ✓ mumkin ✗ mumkin emas
const int *const p ✗ mumkin emas ✗ mumkin emas

Ko‘rsatkichga ko‘rsatkich (int **pp) – boshqa ko‘rsatkichning manzilini saqlaydi. **pp ikki marta murojaat qilib, oxirgi qiymatga yetib boradi. Bu ikki o‘lchovli dinamik massivlarda kerak bo‘ladi (1.5-bo‘lim).

Misol 6: Funksiyadan bir nechta natija qaytarish, const va ko‘rsatkichga ko‘rsatkich
Natija:
Natija bu yerda ko‘rsatiladi...

3-bo‘lim nazorati

Qaysi funksiya main() dagi a va b ning qiymatlarini haqiqatan almashtiradi?

1.4. Dinamik xotira: new va delete

Hozirgacha barcha o‘zgaruvchilar stekda joylashardi: ular o‘lchami kompilyatsiya vaqtida ma’lum bo‘lishi kerak va funksiya tugashi bilan avtomatik o‘chiriladi. Ammo ko‘pincha kerakli xotira hajmi faqat dastur ishlayotganda ma’lum bo‘ladi (masalan, foydalanuvchi nechta son kiritishini oldindan bilmaymiz). Bunday hollarda xotira uyumdan (heap) dinamik ravishda ajratiladi.

Stek (stack) Uyum (heap)
Ajratish Avtomatik, e’lon qilinganda Qo‘lda, new orqali
Bo‘shatish Avtomatik, blok tugaganda Qo‘lda, delete orqali
Hajmi Kichik (odatda 1–8 MB) Katta (operativ xotira hajmicha)
O‘lcham Kompilyatsiya vaqtida ma’lum Ishlash vaqtida aniqlanadi
int *p = new int; // bitta int (qiymati noaniq) int *q = new int(42); // bitta int, 42 bilan int *a = new int[n]; // n ta int dan iborat massiv delete p; // bitta obyektni bo‘shatish delete q; delete[] a; // massivni bo‘shatish – albatta [] bilan! a = nullptr; // osilib qolgan ko‘rsatkichdan saqlanish
Oltin qoida: har bir new ga bitta delete, har bir new[] ga bitta delete[] to‘g‘ri kelishi kerak. Bo‘shatilmagan xotira dastur tugaguncha band bo‘lib qoladi – bu xotira sizishi (memory leak) deyiladi.
🧱 Interaktiv: uyum (heap) simulyatori
Stek – ko‘rsatkichlar:
Uyum – 24 ta int yacheyka (har biri 4 bayt):
p1 bloki p2 bloki p3 bloki sizib ketgan xotira osilib qolgan ko‘rsatkich manzili
Misol 7: Foydalanuvchi aniqlagan o‘lchamdagi dinamik massiv
Kiruvchi ma’lumotlar (stdin): n, keyin n ta baho
Natija:
Natija bu yerda ko‘rsatiladi...
Misol 8: new ning turli shakllari, stek va uyum manzillari
Natija:
Natija bu yerda ko‘rsatiladi...

4-bo‘lim nazorati

int *p = new int[n]; bilan ajratilgan xotira qanday to‘g‘ri bo‘shatiladi?

1.5. Dinamik massivlar: kengaytirish va ikki o‘lchovli massivlar

Massivni kengaytirish

Ajratilgan blokning o‘lchamini o‘zgartirib bo‘lmaydi. Agar joy yetmay qolsa, kattaroq yangi blok ajratiladi, eski elementlar unga nusxalanadi, eski blok bo‘shatiladi va ko‘rsatkich yangi blokka yo‘naltiriladi. Har safar sig‘im (capacity) ikki barobar oshirilsa, nusxalashlar soni kam bo‘ladi – vector ham aynan shunday ishlaydi.

📈 Interaktiv: dinamik massiv o‘sishi
Misol 9: Nechta son kiritilishi noma’lum – massiv o‘zi kengayadi
Kiruvchi ma’lumotlar (stdin): sonlar, oxirida 0
Natija:
Natija bu yerda ko‘rsatiladi...

Ikki o‘lchovli dinamik massiv

Ikki o‘lchovli dinamik massiv – bu ko‘rsatkichlar massivi: avval qatorlarga ko‘rsatkichlar massivi (int* lar) ajratiladi, so‘ng har bir qator uchun alohida blok ajratiladi. Bo‘shatish teskari tartibda bajariladi: avval qatorlar, keyin ko‘rsatkichlar massivi. Qatorlar uzunligi har xil bo‘lishi ham mumkin (masalan, uchburchak shaklidagi massiv).

int **m = new int*[n]; // n ta qator ko‘rsatkichi for (int i = 0; i < n; i++) m[i] = new int[k]; // har bir qator – k ta element m[i][j] = 5; // oddiy matritsa kabi murojaat for (int i = 0; i < n; i++) delete[] m[i]; // 1) avval qatorlar delete[] m; // 2) keyin ko‘rsatkichlar massivi
Misol 10: Dinamik matritsa – qator yig‘indilari
Kiruvchi ma’lumotlar (stdin): n k, keyin matritsa
Natija:
Natija bu yerda ko‘rsatiladi...

5-bo‘lim nazorati

int **m ko‘rinishidagi ikki o‘lchovli dinamik massiv qanday tartibda bo‘shatiladi?

1.6. Xotira bilan bog‘liq xatolar va aqlli ko‘rsatkichlar

Qo‘lda xotira boshqarish kuchli, ammo xavfli vosita. Quyidagi xatolar C++ dasturlarida eng ko‘p uchraydi va ular ko‘pincha kompilyator tomonidan aniqlanmaydi:

Xato Tavsifi
Xotira sizishi (memory leak) Ajratilgan blok manzili yo‘qotiladi va u hech qachon bo‘shatilmaydi.
Osilib qolgan ko‘rsatkich (dangling pointer) Ko‘rsatkich bo‘shatilgan yoki mavjud bo‘lmagan xotirani ko‘rsatadi.
Ikki marta delete (double free) Bitta blok ikki marta bo‘shatiladi – dastur buzilishi mumkin.
new[] / delete mos kelmasligi new[] bilan ajratilgan massiv delete (qavslarsiz) bilan bo‘shatiladi.
nullptr ga murojaat *p, bunda p == nullptr – dastur “Segmentation fault” bilan to‘xtaydi.
🐞 Interaktiv: xatoni toping
Kodda qanday xato bor? Variantni tanlang.

Aqlli ko‘rsatkichlar (smart pointers)

Zamonaviy C++ da (C++11 dan boshlab) xotirani qo‘lda delete qilish o‘rniga <memory> kutubxonasidagi aqlli ko‘rsatkichlar ishlatiladi. Ular doirasidan chiqqanda xotirani avtomatik bo‘shatadi.

Tur Xususiyati
unique_ptr<T> Yagona egasi bor. Nusxalab bo‘lmaydi, faqat move() bilan uzatiladi. Yaratish: make_unique<T>(...).
shared_ptr<T> Bir nechta egasi bo‘lishi mumkin. Ichida hisoblagich (use_count()) bor – oxirgi ega yo‘qolganda xotira bo‘shaydi.
vector<T> Aqlli ko‘rsatkich emas, lekin dinamik massivning xavfsiz o‘rnini bosuvchisi – o‘zi kengayadi va o‘zi bo‘shaydi.
Misol 11: unique_ptr va shared_ptr
Natija:
Natija bu yerda ko‘rsatiladi...
Misol 12: vector – eng xavfsiz dinamik massiv
Kiruvchi ma’lumotlar (stdin): n, keyin n ta son
Natija:
Natija bu yerda ko‘rsatiladi...

6-bo‘lim nazorati

Qaysi aqlli ko‘rsatkichni nusxalab bo‘lmaydi va u doirasidan chiqqanda xotirani avtomatik bo‘shatadi?

🎉 Tabriklaymiz!

Siz “Ko‘rsatkichlar va dinamik xotira bilan ishlash (C++ dasturlash tilida)” mavzusini muvaffaqiyatli yakunladingiz.

Siz ko‘rsatkichlar va manzillar, ko‘rsatkichlar arifmetikasi, funksiyalarga ko‘rsatkich va havola orqali uzatish, new / delete, dinamik massivlar, xotira xatolari hamda aqlli ko‘rsatkichlar bilan tanishdingiz.