University of management and future technologies
Moliya va moliyaviy texnologiyalar
S252-23 MMo'
Guruh talabasi
Rustambekova goʻzal “Dasturlash”fanidan Mustaqil ishi
Toshkent-2024
C++ dasturlash tilida ko’rsatkichlar
C++ Dasturlash Tilida Ko'rsatkichlar Ko'rsatkichlar nima?
Ko'rsatkichlar (pointers) – bu xotira manzillarini saqlaydigan o'zgaruvchilardir. Ular xotiradagi boshqa o'zgaruvchilar yoki ma'lumot strukturalariga ishora qiladi. Ko'rsatkichlar yordamida dasturchilar xotirani dinamik boshqarish va ma'lumotlarga bevosita kirish imkoniyatiga ega bo'lishadi.
Ko'rsatkichlarning asosiy tushunchalari
Ko'rsatkichni aniqlash va ishlatish
Ko'rsatkichlar * (yulduzcha) operatori bilan aniqlanadi:
int *ptr; // bu yerda ptr integer turidagi ko'rsatkich int x = 10;
ptr = &x; // ptr endi x ning manzilini saqlaydi
Ko'rsatkichlar va manzillar
Ko'rsatkichlar o'zgaruvchining xotiradagi manzilini saqlaydi:
int y = 20;
int *ptr_y = &y; // ptr_y endi y ning manzilini saqlaydi
Manzilni olish uchun & (ampersand) operatori ishlatiladi. Ko'rsatkichning qiymatini olish uchun esa * operatori ishlatiladi:
cout << *ptr_y; // bu y ning qiymatini chiqaradi, ya'ni 20
Null pointer
Null pointer – bu hech qanday manzilga ishora qilmaydigan ko'rsatkich. Uni aniqlash uchun nullptr yokiNULL ishlatiladi:
int *ptr = nullptr; // yoki int *ptr = NULL;
Ko'rsatkichlar va massivlar
Ko'rsatkichlar va massivlar o'zaro bog'liq. Massivning birinchi elementi manziliga ko'rsatkich orqali kirish mumkin:
int arr[5] = {1, 2, 3, 4, 5};
int *ptr_arr = arr; // ptr_arr endi arr massivining birinchi elementiga ishora qiladi cout << *ptr_arr; // 1 ni chiqaradi
Ko'rsatkichlarni indekslash orqali massiv elementlariga kirish mumkin:
cout << *(ptr_arr + 1); // 2 ni chiqaradi
Ko'rsatkichlar va funksiyalar
Funksiyalarga ko'rsatkichlar orqali argumentlarni uzatish mumkin:
void increment(int *p) { (*p)++;
}
int main() { int num = 5;
increment(&num);
cout << num; // 6 ni chiqaradi
}
Ko'rsatkichlar va strukturalar
Strukturalar ichidagi elementlarga ko'rsatkichlar orqali kirish mumkin:
struct Point { int x, y;
};
Point p1 = {10, 20}; Point *ptr_p1 = &p1;
cout << ptr_p1->x; // 10 ni chiqaradi
Dinamik xotira boshqaruvi new va delete operatorlari
Dinamik xotira ajratish uchun new, ajratilgan xotirani bo'shatish uchun delete ishlatiladi:
int *ptr = new int; // integer uchun xotira ajratish
*ptr = 25;
delete ptr; // xotirani bo'shatish
Massivlar uchun new va delete[] ishlatiladi:
int *arr = new int[5]; // 5 elementli massiv uchun xotira ajratish delete[] arr; // massiv uchun xotirani bo'shatish
Ko'rsatkichlarning xavfsizligi Dangling Pointer
Dangling pointer – bu avval ajratilgan, lekin keyin bo'shatilgan xotiraga ishora qiladigan ko'rsatkich. Bu ko'rsatkich endi haqiqiy ma'lumotlarga emas, balki bo'sh (yoki o'zgartirilishi mumkin bo'lgan) xotiraga ishora qiladi, bu esa dastur xatosiga olib kelishi mumkin.
Misol:
int* create() {
int* p = new int(5); // dinamik xotira ajratish return p; // ko'rsatkichni qaytarish
}
void destroy(int* p) {
delete p; // xotirani bo'shatish
}
int main() {
int* ptr = create();
cout << *ptr << endl; // 5 ni chiqaradi destroy(ptr); // xotirani bo'shatish
// ptr endi dangling pointer
ptr = nullptr; // xavfsizlik uchun ptr ni nullptr ga o'rnatamiz
}
Memory Leak
Memory leak – bu ajratilgan xotiraning to'g'ri bo'shatilmagan holatidir. Bu dastur xotirasining tugab qolishiga olib kelishi mumkin.
Misol:
#include using namespace std;
void func() {
int *ptr = new int; // xotira ajratish
// xotira bo'shatish delete ptr;
}
int main() {
for(int i = 0; i < 1000; i++) { func();
}
}
Memory leakning oldini olish uchun har doim new bilan ajratilgan xotirani delete bilan bo'shatish kerak.
Ko'rsatkichlarning xavfsiz ishlatilishi bo'yicha amaliy misollar
Misol 1: Ko'rsatkichdan foydalanish:
#include using namespace std;
void safeIncrement(int *p) { if(p != nullptr) {
(*p)++;
}
}
int main() {
int num = 10;
int *ptr = # safeIncrement(ptr);
cout << "Num: " << num << endl; // Num: 11 ni chiqaradi return 0;
}
Ko'rsatkich va dinamik xotira boshqaruvi
#include using namespace std;
int main() {
int *arr = new int[5]; // 5 elementli massiv uchun xotira ajratish for(int i = 0; i < 5; i++) {
arr[i] = i + 1;
}
for(int i = 0; i < 5; i++) { cout << arr[i] << " ";
}
cout << endl;
delete[] arr; // massiv uchun xotirani bo'shatish
arr = nullptr; // xavfsizlik uchun ko'rsatkichni null ga o'rnatamiz
return 0;
}
Xulosa
C++ dasturlash tilida ko'rsatkichlar (pointers) – bu xotira manzillarini saqlaydigan o'zgaruvchilardir. Ular xotiradagi boshqa o'zgaruvchilar yoki ma'lumot strukturalariga ishora qiladi va dasturchilarga xotirani dinamik boshqarish va ma'lumotlarga bevosita kirish imkoniyatini beradi. Ko'rsatkichlar dasturlashda kuchli va qulay vosita bo'lsa-da, ular bilan ishlashda ehtiyotkorlik talab etiladi, chunki noto'g'ri ishlatilgan ko'rsatkichlar dasturda xatoliklar, xotira oqishlari va xavfsizlik muammolariga olib kelishi mumkin.
Hujjat davomida biz ko'rsatkichlarning asosiy tushunchalarini, ko'rsatkichlarni qanday aniqlash va ishlatishni, ko'rsatkichlar va manzillar o'rtasidagi bog'liqlikni, null pointer tushunchasini, ko'rsatkichlar va massivlar, ko'rsatkichlar va funksiyalar, ko'rsatkichlar va strukturalar bilan ishlashni ko'rib chiqdik. Shuningdek, dinamik xotira boshqaruvi uchun new va delete operatorlari haqida tushunchalar berdik va ko'rsatkichlarning xavfsizligi, xususan dangling pointer va memory leak masalalarini yoritdik.
Ko'rsatkichlar mavzusi dasturlashda muhim rol o'ynaydi va dasturchilarga xotira va ma'lumotlarga yuqori darajada boshqaruv imkonini beradi. Ushbu hujjat orqali ko'rsatkichlar bilan bog'liq asosiy tushunchalar va amaliy misollarni o'rganib, dasturiy ta'minotning samaradorligi va xavfsizligini oshirishingiz mumkin.
|
