Dinamik massivlarni yaratish asoslari
![1.1. Dinamik massivlarni yaratish.
C++ tilidagi individual dinamik ob'ektlardan tashqari biz dinamik
massivlardan ham foydalanishimiz mumkin. Dinamik massivda xotirani ajratish
uchun new operatori ham ishlatiladi , shundan so'ng kvadrat qavs ichida massivda
nechta ob'ekt bo'lishi ko'rsatiladi:
int *numbers {new int[4]}; // 4 ta elementdan iborat massiv
// yoki
// int *numbers = new int[4];
Bundan tashqari, bu holda, yangi operator int tipidagi ob'ektga ko'rsatgichni
qaytaradi - yaratilgan massivning birinchi elementi.
Bunday holda, to'rtta int elementli massiv aniqlanadi, lekin ularning har biri
aniqlanmagan qiymatga ega. Biroq, biz qiymatlar bilan massivni ishga
tushirishimiz ham mumkin:
int *numbers1 {new int[4]{}}; // massiv elementlari 0, 0, 0, 0
int *numbers2 {new int[4]{ 1, 2, 3, 4 }}; // massiv elementlari 1, 2, 3, 4
int *numbers3 {new int[4]{ 1, 2 }}; // massiv elementlari 1, 2, 0, 0
// o'xshash massiv ta'riflari
// int *numbers1 = new int[4]{}; // massiv elementlari 0, 0, 0, 0
// int *numbers1 = new int[4](); // massiv elementlari 0, 0, 0, 0
// int *numbers2 = new int[4]{ 1, 2, 3, 4 }; // massiv elementlari 1, 2, 3, 4
// int *numbers3 = new int[4]{ 1, 2 }; // massiv elementlari 1, 2, 0, 0
Muayyan qiymatlar bilan massivni ishga tushirishda shuni yodda tutingki,
agar figurali qavslarda massiv uzunligidan ko'proq qiymatlar bo'lsa, yangi operator
ishlamay qoladi va massivni yarata olmaydi. Agar aksincha, kamroq qiymatlar
5](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_5.png)
![o'tgan bo'lsa, unda hech qanday qiymat ko'rsatilmagan elementlar standart qiymat
bilan ishga tushiriladi.
Shuni ta'kidlash kerakki, C++20 standarti massiv hajmini ko'rsatish
imkoniyatini qo'shdi, shuning uchun agar C++20 standarti ishlatilsa, unda siz
massiv uzunligini ko'rsata olmaysiz:
int *numbers {new int[]{ 1, 2, 3, 4 }}; // massiv elementlari 1, 2, 3, 4
Dinamik massivni yaratgandan so'ng, biz qabul qilingan ko'rsatgich
yordamida u bilan ishlashimiz, uning elementlarini olishimiz va o'zgartirishimiz
mumkin:
int *numbers {new int[4]{ 1, 2, 3, 4 }};
// massiv sintaksisi orqali elementlarni olish
std::cout << numbers[0] << std::endl; // 1
std::cout << numbers[1] << std::endl; // 2
// dereferent operatsiyasi orqali elementlarni olish
std::cout << *numbers << std::endl; // 1
std::cout << *(numbers+1) << std::endl; // 2
Bundan tashqari, dinamik massivning elementlariga kirish uchun siz massiv
sintaksisidan ( numbers[0]) va yo'qotish operatsiyasidan ( *numbers)
foydalanishingiz mumkin.
Shunga ko'ra, bunday massivni takrorlash uchun siz turli usullardan
foydalanishingiz mumkin:
unsigned n{ 5 }; // massiv o’lchami
int* p{ new int[n] { 1, 2, 3, 4, 5 } };
for (unsigned i{}; i < n; i++)
{
6](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_6.png)
![std::cout << p[i] << "\t";
}
std::cout << std::endl;
for (unsigned i{}; i < n; i++)
{
std::cout << *(p+i)<< "\t";
}
std::cout << std::endl;
// yordamchi ko'rsatgich yordamida massiv bo'ylab takrorlash
for (int* q{ p }; q != p + n; q++)
{
std::cout << *q << "\t";
}
std::cout << std::endl;
E'tibor bering, biz standart massivlarda bo'lgani kabi, dinamik massiv
hajmini o'rnatish uchun doimiy emas, oddiy o'zgaruvchidan foydalanishimiz
mumkin.
Dinamik massivni o'chirish va uning xotirasini bo'shatish uchun o'chirish
operatorining maxsus shakli qo'llaniladi :
delete []
dinamik_massivga ko'rsatgich;
Masalan:
#include <iostream>
7](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_7.png)
![int main()
{
unsigned n{ 5 }; // massiv o’lchami
int* p{ new int[n] { 1, 2, 3, 4, 5 } };
// indekslardan foydalaning
for (unsigned i{}; i < n; i++)
{
std::cout << p[i] << "\t";
}
std::cout << std::endl;
delete [] p;
}
Xotira bo'shatilgandan so'ng, ko'rsatgich eski manzilni saqlamasligi uchun
uni nolga qaytarish tavsiya etiladi:
delete [] p;
p = nullptr; // ko'rsatkichni nolga aylantiring
1.2. Ko'p o'lchovli massivlar.
Biz ko'p o'lchovli dinamik massivlarni ham yaratishimiz mumkin. Ikki
o'lchovli massivlar misolini ko'rib chiqaylik. Ikki o'lchovli massiv aslida nima? Bu
massivlar to'plamidir. Shunga ko'ra, dinamik ikki o'lchovli massivni yaratish uchun
biz ko'rsatkichlarning umumiy dinamik massivini, keyin esa uning elementlarini -
ichki o'rnatilgan dinamik massivlarni yaratishimiz kerak. Umuman olganda, u
quyidagicha ko'rinadi:
#include <iostream>
8](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_8.png)
![int main()
{
unsigned rows = 3; // qatorlar soni
unsigned columns = 2; // ustunlar soni
int** numbers{new int*[rows]{}}; // ikki o'lchovli massiv uchun xotira
ajratish
// ichki joylashtirilgan massivlar uchun xotira ajratish
for (unsigned i{}; i < rows; i++)
{
numbers[i] = new int[columns]{};
}
// massivlarni o'chirish
for (unsigned i{}; i < rows; i++)
{
delete[] numbers[i];
}
delete[] numbers;
}
Birinchidan, biz ko'rsatkichlar majmuasi uchun xotira ajratamiz (shartli
jadvallar):
int** numbers{new int*[rows]{}};
Keyin, tsiklda biz har bir alohida massiv uchun xotira ajratamiz (shartli
jadval qatorlari):
numbers[i] = new int[columns]{};
9](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_9.png)
![Xotirani chiqarish teskari tartibda amalga oshiriladi - avval biz xotirani har
bir ichki o'rnatilgan massiv uchun, keyin esa butun ko'rsatkichlar massivi uchun
bo'shatamiz.
Ikki o'lchovli dinamik massivning ma'lumotlarini kiritish va chiqarishga
misol:
#include <iostream>
int main()
{
unsigned rows = 3;
unsigned columns = 2;
int** numbers{new int*[rows]{}};
// ikki o'lchovli massiv uchun xotira ajratish
for (unsigned i{}; i < rows; i++)
{
numbers[i] = new int[columns]{};
}
// jadval satrlari x ustunlari uchun ma'lumotlarni kiriting
for (unsigned i{}; i < rows; i++)
{
std::cout << "Enter data for " << (i + 1) << " row" << std::endl;
// i-qator ustunlari uchun ma'lumotlarni kiriting
for (unsigned j{}; j < columns; j++)
{
10](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_10.png)
![std::cout << (j + 1) << " column: ";
std::cin >> numbers[i][j];
}
}
// ma'lumotlar chiqishi
for (unsigned i{}; i < rows; i++)
{
// i-qator ustunlari ma'lumotlarini ko'rsatish
for (unsigned j{}; j < columns; j++)
{
std::cout << numbers[i][j] << "\t";
}
std::cout << std::endl;
}
for (unsigned i{}; i < rows; i++)
{
delete[] numbers[i];
}
delete[] numbers;
}
Dasturning ishlashiga misol:
1 qator uchun ma'lumotlarni kiriting
11](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_11.png)
![1 ustun: 2
2 ustun: 3
2 qator uchun ma'lumotlarni kiriting
1 ustun: 4
2 ustun: 5
3 qator uchun ma'lumotlarni kiriting
1 ustun: 6
2 ustun: 7
2 3
4 5
6 7
1.3. Massivga ko'rsatgich .
Int ** massivga ko'rsatgich e’lon qilish. Masalan:
#include <iostream>
int main()
{
unsigned n{3}; // qatorlar soni
int (*a)[2] = new int[n][2];
int k{};
// qiymatlarni o'rnatish
for (unsigned i{}; i < n; i++)
{
// i-qator ustunlari uchun ma'lumotlarni o'rnating
12](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_12.png)
![for (unsigned j{}; j < 2; j++)
{
a[i][j] = ++k;
}
}
// ma'lumotlar chiqishi
for (unsigned i{}; i < n; i++)
{
// i-qator ustunlari ma'lumotlarini ko'rsatish
for (unsigned j{}; j < 2; j++)
{
std::cout << a[i][j] << "\t";
}
std::cout << std::endl;
}
// ma'lumotlarni o'chirish
delete[] a;
a = nullptr;
}
Bu erda yozuv int (*a)[2]ikkita int elementli massivga ko'rsatgichni
ifodalaydi. Aslida, biz ushbu ob'ekt bilan ikki o'lchovli massiv (jadval) bilan
ishlashimiz mumkin, bu holda faqat ustunlar soni aniqlangan - 2. Va bunday
massiv uchun xotira bir marta ajratiladi:
13](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_13.png)
![int (*a)[2] = new int[n][2];
Ya'ni, bu holda biz n satr va 2 ustundan iborat jadval bilan ishlaymiz. Ikkita
indeksdan (biri satr uchun, biri ustun uchun) foydalanib, ma'lum bir elementga
kirish, uning qiymatini belgilash yoki olish mumkin.
Dinamik massivlarning kamchiliklari. Aytaylik, biz massivga juda katta
ob’ektlarni tez-tez qo'shishimiz va olib tashlashimiz kerak. Bunday holda, ob'ektlar
ko'pincha boshqa joylarga ko'chirilishi mumkin va ko'plab ko'rsatkichlar bekor
bo'ladi. Agar siz dinamik massivning o'rtasida tez-tez o'zgartirishlar kiritishingiz
kerak bo'lsa, unda buning uchun chiziqli ma'lumotlar strukturasining yanada mos
turi mavjud.
14](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_14.png)
![Quyidagi kodda massiv o'lcham bilan to'la bo'ladi, biz barcha elementni
yangi ikki o'lchamli massivga (o'zgaruvchan o'lchamli massiv) ko'chiramiz. Kod
namunasi quyida keltirilgan:
#include <iostream>
using namespace std;
class DynamicArray {
private:
// Pointer to store array created
// using new keyword
int* array = NULL;
// Size of array
int size;
// Container size
int capacity;
public:
// Default constructor with size 1
DynamicArray()
{
capacity = 1;
size = 0;
array = new int[capacity];
}
// Taking size from the user
DynamicArray(int capacity)
{
this->capacity = capacity;
array = new int[capacity];
size = 0;
}
19](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_19.png)
![// Returns the size of Array
// i.e Total elements stored currently
int getSize() { return size; }
// Returns the size of container
int getCapacity() { return capacity; }
// Inserting element after last stored index
void push_back(int value)
{
// check is array having size to store element or
// not
if (size == capacity) {
// if not then grow the array by double
growArray();
}
// insert element
array[size] = value;
// increment the size or last_index+1
size++;
}
// Deleting element at last stored index
void pop_back()
{
// Replace the last index by 0
array[size - 1] = 0;
// Decrement the array size
size--;
// Reduce if the container half element of its
// capacity
if (size == (capacity / 2)) {
20](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_20.png)
![shrinkArray();
}
}
// Increase the array size by double of current capacity
void growArray()
{
// Creating new array of double size
int* temp = new int[capacity * 2];
capacity = capacity * 2;
// copy element of old array in newly created array
for (int i = 0; i < size; i++) {
temp[i] = array[i];
}
// Delete old array
delete[] array;
// Assign newly created temp array to original array
array = temp;
}
// Reduce the size of array by half
void shrinkArray()
{
// Creating new array of half size
capacity = size;
int* temp = new int[capacity];
// copy element of old array in newly created array
for (int i = 0; i < size; i++) {
temp[i] = array[i];
}
21](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_21.png)
![// Delete old array
delete[] array;
// Assign newly created temp array to original array
array = temp;
}
// Searching element in the given array
int search(int key)
{
for (int i = 0; i < size; i++) {
if (array[i] == key) {
// If element found return its index
return i;
}
}
// Return -1 if element not found;
return -1;
}
// Insert element at given index
void insertAt(int index, int value)
{
// check is array having size to store element or
// not
if (size == capacity) {
// if not then grow the array by double
growArray();
}
for (int i = size - 1; i >= index; i--) {
array[i + 1] = array[i];
}
22](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_22.png)
![array[index] = value;
size++;
}
// Delete element at given index
void deleteAt(int index)
{
for (int i = index; i < size; i++) {
array[i] = array[i + 1];
}
// Replace the last index by 0
array[size - 1] = 0;
// Decrement the array size
size--;
// Reduce if the container half element of its
// capacity
if (size == (capacity / 2)) {
shrinkArray();
}
}
// To Print Array
void printArrayDetails()
{
cout << "Elements of array : ";
for (int i = 0; i < size; i++) {
cout << array[i] << " ";
}
cout << endl;
cout << "No of elements in array : " << size
<< ", Capacity of array :" << capacity << endl;
23](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_23.png)
![Misol:
#include<iostream>
using namespace std;
int main() {
int x, n;
cout << "Enter the number of items:" << "\n";
cin >>n;
int *arr = new int(n);
cout << "Enter " << n << " items" << endl;
for (x = 0; x < n; x++) {
cin >> arr[x];
}
cout << "You entered: ";
for (x = 0; x < n; x++) {
cout << arr[x] << " ";
}
return 0;
}
Kod tushuntirilishi:
Funktsiyalardan foydalanish uchun iostream sarlavha faylini dasturimizga
qo'shamiz.
Std nom maydonini standart nomlar fazosidan foydalanish uchun
dasturimizga qo'shamiz.
34](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_34.png)
![buni amalga oshirishga yordam beradi. Keyin bo'shatilgan xotira maydoni boshqa
ma'lumotlar to'plamini saqlash uchun ishlatilishi mumkin. Biroq, dinamik massivni
kompyuter xotirasidan o'chirmasangiz ham, dastur tugagandan so'ng u avtomatik
ravishda o'chiriladi. Eslatma:
Dinamik massivni kompyuter xotirasidan o chirish uchun delete[] dan ʻ
foydalaning. [] protsessorga bitta o'zgaruvchini emas, balki bir nechta
o'zgaruvchilarni o'chirishni buyuradi. Dinamik massiv bilan ishlashda
delete[] o‘rniga o‘chirishdan foydalanish muammolarga olib kelishi
mumkin. Bunday muammolarga misollar xotiraning oqishi, ma'lumotlarning
buzilishi, buzilishlar va boshqalarni o'z ichiga oladi.
36](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_36.png)
![XULOSA
Xulosa qilib shuni aytish mumkinki , C++ dasturlash tilida ishlash boshqa
dasturlash tillariga nisbatan ancha qulay va imkonoyati ham kengroq. Men C+
+ dasturi strukturasi xaqida, belgilar bayoni , Algoritm va dastur tushunchasi, ma’lum
otlarni kiritish va chikarish operatorlari xamda dasturda massivlar va satrlar bilan ishl
ash xaqida o`zimga keraklicha bilim va ko`nikmaga ega bo`ldim.
C++dasturi Windows muhitida ishlaydigan dastur tuzish uchun qulay bo`lgan vosita
bo`lib, kompyuterda dastur yaratish ishlarini avtomatlashtiradi, xatoliklarni kamaytira
di va dastur tuzuvchi mehnatini yengillashtiradi. C++ dasturlash tilida massivlarning
ishlatilishi boshqa dasturlash tillariga qaraganda bir muncha afzalliklarga ega.
Massivlar bilan ishlash bazi hisoblash masalalarida ancha qulayliklar tug`diradi.
Ularning xotirada egallaydigan joyini hisobga olsak dasturning ishlash tezligi xam bir
necha marta ortadi.
Men bu kurs ishimda shuni yoritib berganmanki , massivlar xaqida umumiy
ma`lumot (bir o`lchamli va ko`p o`lchamli), ularning xotiradan egallaydigan tartibi,
saralash, tartiblash, funksiyalar bilan bog`lash , dasturlarda foydalanish kabi
yechimlariga oid turli masalalarni misollar yordamida yoritib chiqdim.Shunday
holatlar bo'lishi mumkinki, dasturning xotiraga bo'lgan ehtiyojini faqat ish paytida
aniqlash mumkin. Masalan, qachon kerakli xotira foydalanuvchi kiritishiga bog'liq.
Ushbu holatlarda dasturlarga xotirani dinamik ravishda ajratish kerak, buning uchun
C ++ tili new () va delete () operatorlarini birlashtiradi. Dinamik xotira new ()
operatori yordamida ajratiladi. new () dan keyin ma'lumotlar turini aniqlovchi va agar
bir nechta elementlar ketma-ketligi zarur bo'lsa, ularning soni qavs ichida [] bo'ladi.
U ko'rsatgichni ajratilgan yangi xotira blokining boshiga qaytaradi. Dinamik massiv
odatda eng yaxshi tanlovdir.
37](/data/documents/6fed6788-c0b5-4e19-a828-065e6416a1b8/page_37.png)
Dinamik massivlarni yaratish asoslari MUNDARIJA KIRISH .......................................................................................................................................................... 2 1.Dinamik massiv ......................................................................................................................................... 3 Dinamik massiv, shuningdek, o'lchamlarini o'zgartiradigan massiv sifatida ham tanilgan, bu ish vaqtida uning imkoniyatlarini moslashuvchan o'lchamlarini o'zgartirishga imkon beradigan ma'lumotlar tuzilishi. O'zgartirib bo'lmaydigan sobit o'lchamga ega bo'lgan statik massivlardan farqli o'laroq, dinamik massivlar kerak bo'lganda o'sishi yoki kichrayishi mumkin. ......................................................................... 3 Dasturlashda dinamik massivlar odatda saqlanadigan ma'lumotlarning aniq hajmi noma'lum bo'lganda yoki vaqt o'tishi bilan o'zgarishi mumkin bo'lganda ishlatiladi. Ushbu massivlar xotirani dinamik ravishda ajratadi va ko'proq elementlarni qo'shish yoki mavjud elementlarni olib tashlash kerak bo'lganda o'lchamlarini o'zgartirish mumkin. .............................................................................................................. 3 O'lchamini o'zgartirish jarayoni odatda yangi, kattaroq xotira blokini ajratishni, unga mavjud elementlarni nusxalashni va eski xotira blokini taqsimlashni o'z ichiga oladi. Bu dinamik massivga xotirani isrof qilmasdan ko'proq elementlarni joylashtirishga imkon beradi. Aksincha, agar elementlar olib tashlansa, xotirani tejash uchun massiv qisqarishi mumkin. ....................................................................... 3 Dinamik massivlar statik massivlarga o'xshash samarali tasodifiy kirishning afzalliklarini taklif qiladi, shu bilan birga dinamik o'lchamlarning moslashuvchanligini ta'minlaydi. Biroq, o'lchamlarni o'zgartirish operatsiyalari vaqt jihatidan nisbatan qimmatga tushishi mumkin, chunki xotirani qayta taqsimlash va nusxalash ishtirok etadi. .............................................................................................................................. 3 1.1. Dinamik massivlarni yaratish. ............................................................................................................... 5 1.2. Ko'p o'lchovli massivlar. ........................................................................................................................ 8 2. Ob'ektni dinamik massivga qo'shish va o’chirish ................................................................................... 15 2.1. Dinamik massivdan olib tashlash. ....................................................................................................... 16 2.2. Dinamik massiv uchun oddiy kod. ....................................................................................................... 18 3. Ma'lumotlar tuzilmalari ......................................................................................................................... 26 4. Dinamik massivlarning ishlashiga ta'sir qiluvchi omillar ......................................................................... 33 XULOSA ..................................................................................................................................................... 37 FOYDALANILGAN ADABIYOTLAR ................................................................................................................ 38 1
KIRISH Dinamik massivlar birinchi marta kompyuter dasturlashda ma'lumotlar tuzilishi tushunchasi sifatida kiritilgan. Ularning yaratilishining aniq tarixi har xil bo'lishi mumkin, ammo ularning rivojlanishini dasturlash tillari va xotirani boshqarish texnikasidagi yutuqlar bilan bog'lash mumkin. Dasturlashning dastlabki kunlarida odatda ma'lumotlarni saqlash va boshqarish uchun sobit o'lchamdagi massivlar ishlatilgan. Biroq, sobit o'lchamdagi massivlarning cheklanishi ishlab chiquvchilar turli xil ma'lumotlarni joylashtirish uchun zarur bo'lganda yoki dasturni bajarish paytida massivning hajmi dinamik ravishda o'zgarishi uchun zarur bo'lganda aniq bo'ldi. Ushbu muammoning echimi sifatida dinamik massivlar tushunchasi paydo bo'ldi. Belgilangan hajmdagi xotirani ajratish o'rniga, dinamik massivlar haqiqiy hajm talablari asosida ish vaqtida xotirani ajratish va qayta taqsimlashga imkon beradi. Massiv hajmini oshirish kerak bo'lganda, dinamik massiv kattaroq xotira blokini ajratadi va mavjud ma'lumotlarni yangi xotira maydoniga ko'chiradi. Xuddi shunday, massiv hajmini kamaytirish kerak bo'lganda, massiv kichikroq xotira blokini qayta taqsimlashi va shunga mos ravishda sozlashi mumkin. Dinamik massivlarni amalga oshirish va qo'llab- quvvatlash yillar davomida turli dasturlash tillariga birlashtirilgan. Masalan, C++ da dinamik massivlar odatda "yangi" kalit so'z yordamida yaratiladi va ko'rsatkichlar bilan boshqariladi. Python kabi boshqa tillar avtomatik ravishda xotirani ajratish va dinamik massivlar uchun qayta taqsimlashni ro'yxatlar kabi 2
o'zlarining mahalliy ma'lumotlar tuzilmalari orqali boshqaradi. Umuman olganda, dinamik massivlarning yaratilishi va evolyutsiyasi dasturlash tillarida moslashuvchan ma'lumotlar tuzilmalariga bo'lgan ehtiyoj bilan bog'liq bo'lib, ishlab chiquvchilarga dasturni bajarish paytida turli xil ma'lumotlarni samarali boshqarish va boshqarish imkoniyatini beradi. 1.Dinamik massiv Dinamik massiv, shuningdek, o'lchamlarini o'zgartiradigan massiv sifatida ham tanilgan, bu ish vaqtida uning imkoniyatlarini moslashuvchan o'lchamlarini o'zgartirishga imkon beradigan ma'lumotlar tuzilishi. O'zgartirib bo'lmaydigan sobit o'lchamga ega bo'lgan statik massivlardan farqli o'laroq, dinamik massivlar kerak bo'lganda o'sishi yoki kichrayishi mumkin. Dasturlashda dinamik massivlar odatda saqlanadigan ma'lumotlarning aniq hajmi noma'lum bo'lganda yoki vaqt o'tishi bilan o'zgarishi mumkin bo'lganda ishlatiladi. Ushbu massivlar xotirani dinamik ravishda ajratadi va ko'proq elementlarni qo'shish yoki mavjud elementlarni olib tashlash kerak bo'lganda o'lchamlarini o'zgartirish mumkin. O'lchamini o'zgartirish jarayoni odatda yangi, kattaroq xotira blokini ajratishni, unga mavjud elementlarni nusxalashni va eski xotira blokini taqsimlashni o'z ichiga oladi. Bu dinamik massivga xotirani isrof qilmasdan ko'proq elementlarni joylashtirishga imkon beradi. Aksincha, agar elementlar olib tashlansa, xotirani tejash uchun massiv qisqarishi mumkin. Dinamik massivlar statik massivlarga o'xshash samarali tasodifiy kirishning afzalliklarini taklif qiladi, shu bilan birga dinamik o'lchamlarning moslashuvchanligini ta'minlaydi. Biroq, o'lchamlarni o'zgartirish operatsiyalari vaqt jihatidan nisbatan qimmatga tushishi mumkin, chunki xotirani qayta taqsimlash va nusxalash ishtirok etadi. 3
Dinamik massivlar dasturlash tillarida massiv hajmini kompilyatsiya vaqtida emas, balki ish vaqtida aniqlash kerak bo'lgan vaziyatlarni boshqarish uchun ishlatiladi. Dinamik massivlar uchun bir nechta umumiy foydalanish holatlari: 1. Dinamik xotirani taqsimlash: dinamik massivlar ish vaqtida massiv uchun xotirani ajratishga imkon beradi, bu massiv hajmi oldindan ma'lum bo'lmaganda yoki dasturni bajarish paytida o'zgarishi mumkin bo'lganda foydali bo'lishi mumkin. Bu odatda C/C++ da `malloc()` yoki C++ yoki Java kabi tillarda `new` operatori kabi funktsiyalar yordamida amalga oshiriladi. 2. Moslashuvchan ma'lumotlar tuzilmalari: dinamik massivlar ko'pincha ro'yxatlar, stacklar, navbatlar va vektorlar kabi dinamik ma'lumotlar tuzilmalarini amalga oshirish uchun ishlatiladi. Dinamik massivlar yordamida siz kerak bo'lganda elementlarni osongina qo'shishingiz yoki olib tashlashingiz mumkin, bu esa ma'lumotlarni samarali o'lchamlarini va manipulyatsiyasini ta'minlaydi. 3. Katta ma'lumotlar bilan ishlash: agar sizda dastlab xotiraga sig'maydigan juda katta ma'lumotlar to'plamlari bo'lsa, dinamik massivlar ma'lumotlarning bir qismini dinamik ravishda yuklash va boshqarish uchun ishlatilishi mumkin. Bu katta ma'lumotlar to'plamlarini samarali qayta ishlash va manipulyatsiya qilish imkonini beradi, chunki siz bir vaqtning o'zida ma'lumotlarning qismlarini yuklashingiz va qayta ishlashingiz mumkin. 4. Resizable konteynerlarini amalga oshirish: dinamik massivlar odatda Java-dagi ArrayList yoki C++ - dagi vektor kabi o'lchamli konteynerlar uchun asosiy ma'lumotlar tuzilishi sifatida ishlatiladi. Ushbu konteynerlar elementlar qo'shilishi yoki olib tashlanishi bilan massivning hajmini dinamik ravishda o'zgartirish imkoniyatini beradi, bu ularni ma'lumotlar to'plamlarini boshqarish uchun foydali qiladi. Umuman olganda, dinamik massivlar dasturni bajarish paytida massiv hajmi dinamik ravishda o'zgarishi kerak bo'lgan stsenariylarda moslashuvchanlikni ta'minlaydi. 4
1.1. Dinamik massivlarni yaratish. C++ tilidagi individual dinamik ob'ektlardan tashqari biz dinamik massivlardan ham foydalanishimiz mumkin. Dinamik massivda xotirani ajratish uchun new operatori ham ishlatiladi , shundan so'ng kvadrat qavs ichida massivda nechta ob'ekt bo'lishi ko'rsatiladi: int *numbers {new int[4]}; // 4 ta elementdan iborat massiv // yoki // int *numbers = new int[4]; Bundan tashqari, bu holda, yangi operator int tipidagi ob'ektga ko'rsatgichni qaytaradi - yaratilgan massivning birinchi elementi. Bunday holda, to'rtta int elementli massiv aniqlanadi, lekin ularning har biri aniqlanmagan qiymatga ega. Biroq, biz qiymatlar bilan massivni ishga tushirishimiz ham mumkin: int *numbers1 {new int[4]{}}; // massiv elementlari 0, 0, 0, 0 int *numbers2 {new int[4]{ 1, 2, 3, 4 }}; // massiv elementlari 1, 2, 3, 4 int *numbers3 {new int[4]{ 1, 2 }}; // massiv elementlari 1, 2, 0, 0 // o'xshash massiv ta'riflari // int *numbers1 = new int[4]{}; // massiv elementlari 0, 0, 0, 0 // int *numbers1 = new int[4](); // massiv elementlari 0, 0, 0, 0 // int *numbers2 = new int[4]{ 1, 2, 3, 4 }; // massiv elementlari 1, 2, 3, 4 // int *numbers3 = new int[4]{ 1, 2 }; // massiv elementlari 1, 2, 0, 0 Muayyan qiymatlar bilan massivni ishga tushirishda shuni yodda tutingki, agar figurali qavslarda massiv uzunligidan ko'proq qiymatlar bo'lsa, yangi operator ishlamay qoladi va massivni yarata olmaydi. Agar aksincha, kamroq qiymatlar 5