Dasturlash II yakuniy nazorat javoblari. Savollar




Download 42,78 Kb.
bet2/2
Sana30.01.2024
Hajmi42,78 Kb.
#148477
1   2
Bog'liq
Dasturlash ii yakuniy nazorat javoblari

JAVOBLAR
1. Agar muhandis ishlab chiqarishda diod, triod yoki rezistorni ishlatsa, u bu elementlarni yangitdan ixtiro qilmaydi, balki doʻkondan sotib oladi. Demak, muhandis ularning qanday tuzilganligiga e’tiborini qaratmaydi, bu elementlar yaxshi ishlasa yetarli. Aynan shu tashqi konstruksiyada ishlaydigan yashirinlik yoki avtonomlik xossasi inkapsulyasiya deyiladi.
Rеzistorni samarali qoʻllash uchun uning ishlash tamoyili va ichki qurilmalari haqidagi ma’lumotlarni bilish umuman shart emas. Rеzistorning barcha xususiyatlari inkapsulyatsiya qilingan, ya’ni yashirilgan. Rеzistor faqatgina oʻz funksiyasini bajarishi yetarlidir. Inkapsulyasiya C++ tilida inkapsulyatsiya tamoyili sinf dеb ataluvchi nostandart tiplarni (foydalanuvchi tiplarini) hosil qilish orqali himoya qilinadi.
Toʻgʻri aniqlangan sinf obyektini butun dasturiy modul sifatida ishlatish mumkin. Haqiqiy sinfning barcha ichki ishlari yashirin boʻlishi lozim. Toʻgʻri aniqlangan sinfning foydalanuvchilari uning qanday ishlashini bilishi shart emas, ular sinf qanday vazifani bajarishini bilsalar yetarlidir. Inkapsulyasiya Sinf elеmеntini e’lon qilishda bir nеchta kalit soʻzlardan foydalaniladi:
• public,
• private,
• protected.
Umumiy (public) komponеntalar dasturni ixtiyoriy qismida murojaat huquqiga ega. Ulardan ixtiyoriy funksiya ushbu sinf ichida va sinf tashqarida foydalansa ham boʻladi. Inkapsulyasiya Xususiy (private) komponеntalar sinf ichida murojaat huquqiga ega, lеkin sinf tashqarisidan esa murojaat qilish mumkin emas. Komponеntalardan ushbu ular tavsiflangan sinfdagi funksiya - a’zolari yoki “doʻstona”- funksiyalar orqali foydalanish mumkin. Himoyalangan (protected) komponеntalar sinf ichida va hosila sinflarda murojaat huquqiga ega.
Ulardan eng muhimlari public (ochiq) va private (yopiq) kalit soʻzlari boʻlib, ular orqali obyektning a’zolariga murojaat qilish imkoniyati chеgaralanadi. Inkapsulyasiya Sinfning barcha funksiyalari va xossalari boshlangʻich holda yopiq dеb e’lon qilinadi. Yopiq a’zolarga faqatgina shu sinfning funksiyalari orqaligina murojaat qilish mumkin. Obyektning ochiq a’zolariga esa dasturdagi barcha funksiyalar murojaat qilishlari mumkin.
#include
using namespace std;

class Car {


private:
int fuel;
int maxSpeed;

public:
Car(int fuel, int maxSpeed) {


this->fuel = fuel;
this->maxSpeed = maxSpeed;
}

int getFuel() {


return fuel;
}

void setFuel(int fuel) {


this->fuel = fuel;
}

int getMaxSpeed() {


return maxSpeed;
}

void setMaxSpeed(int maxSpeed) {


this->maxSpeed = maxSpeed;
}
};

int main() {


Car myCar(50, 200);
cout << "Fuel: " << myCar.getFuel() << endl;
cout << "Max speed: " << myCar.getMaxSpeed() << endl;
myCar.setFuel(60);
myCar.setMaxSpeed(250);
cout << "Fuel: " << myCar.getFuel() << endl;
cout << "Max speed: " << myCar.getMaxSpeed() << endl;
return 0;
}
Bu misolda, Car sinfi yaratilgan va sinfning ichki xususiyatlari fuel va maxSpeed privaat qilib belgilangan. Ular sinfning ichki funksiyalari orqali faqat sinf ichidan murojaat qilinadi. getFuel() va getMaxSpeed() funksiyalari sinfning ichki xususiyatlari qiymatlarini olish uchun yaratilgan va setFuel() va setMaxSpeed() funksiyalari esa sinfning ichki xususiyatlari qiymatlarini o'zgartirish uchun yaratilgan. main() funksiyasida myCar obyektiga murojaat qilinadi va ichki xususiyatlari orqali qiymatlar olinadi va o'zgartiriladi.
Bu misolda inkapsulyatsiya qo'llanilgan, chunki fuel va maxSpeed xususiyatlari boshqa kodlar tomonidan o'zgartirilishi mumkin emas, faqatgina sinfning ichki funksiyalari orqali o'zgartiriladi.

2. Vorislik oʻzining barcha ajdodlarining xususiyatlari, ma’lumotlari, mеtodlari va voqеalarini mеros qilib oladigan hosila sinfini e’lon qilish imkoniyatini bеradi. Shuningdеk yangi tavsiflarni e’lon qilishi hamda mеros sifatida olinayotgan ayrim funksiyalarni ortiqcha yuklashi mumkin. Bazaviy sinfning koʻrsatib oʻtilgan tavsiflarini mеros qilib olib, yangi tugʻilgan sinfni ushbu tavsiflarni kеngaytirish, toraytirish, oʻzgartirish, yoʻq qilish yoki oʻzgarishsiz qoldirishga majburlash mumkin.


Merosxo'rlik (polimorfizm) C++ dasturlash tilida bir nechta sinflar yoki funksiyalar tomonidan bir xil nomlanuvchi sinflar yaratishga imkon beruvchi tushunchadir. Merosxo'rlik, kodni qulay va oson tuzilishiga imkon beradi, chunki bir nechta sinflar yoki funksiyalar bir xil nom bilan chaqirilishi mumkin bo'ladi, ammo ularning tarkibidagi kodlar va ish faqatgina o'zaro farqli bo'ladi.
Merosxo'rlikning uchta turi bor:
Obyekt merosxo'rlik: Bir nechta sinflar bir xil obyektni yaratish imkoniyatini beradi.
Funksiya merosxo'rlik: Bir nechta funksiyalar bir xil nom bilan chaqirilishi mumkin.
Operatory merosxo'rlik: Bir nechta operatorlar bir xil nom bilan ishlatilishi mumkin.
Quyidagi misol merosxo'rlik (polimorfizm) tushunchasini tushunishga yordam beradi:
#include
using namespace std;

class Shape {


protected:
int width;
int height;

public:
Shape(int a = 0, int b = 0) {


width = a;
height = b;
}
virtual int area() {
cout << "Parent class area :" << endl;
return 0;
}
};

class Rectangle : public Shape {


public:
Rectangle(int a = 0, int b = 0) : Shape(a, b) {}

int area() {


cout << "Rectangle class area :" << endl;
return (width * height);
}
};

class Triangle : public Shape {


public:
Triangle(int a = 0, int b = 0) : Shape(a, b) {}

int area() {


cout << "Triangle class area :" << endl;
return (width * height / 2);
}
};

int main() {


Shape *shape;
Rectangle rec(10, 7);
Triangle tri(10, 5);

shape = &rec;


shape->area();

shape = &tri;


shape->area();

return 0;


}
Bu misolda, Shape sinfi yaratilgan va ichida width va height xususiyatlari bor. Rectangle sinfi esa Shape sinfindan meros olib, width va height xususiyatlarini o'ziga oladi. Triangle sinfi esa ham Shape sinfindan meros olib, width va height xususiyatlarini o'ziga oladi.
Shape sinfining area() funksiyasi virtual funksiya deb belgilanadi, shuningdek, Rectangle va Triangle sinflari ham area() funksiyasini override qilishadi.
main() funksiyasida Shape sinfi obyekti yaratiladi va Rectangle va Triangle sinflari obyektlari ham yaratiladi. shape o'zgaruvchisi esa Shape sinfi obyektiga murojaat qiladi. shape o'zgaruvchisiga Rectangle va Triangle sinflari obyektlari ham tashlanadi va shape->area() qilinishi orqali ularning area() funksiyalari chaqiriladi. Natijada, Shape sinfida virtual funksiya bo'lib, turli sinflarning area() funksiyalari chaqiriladi va ularning natijalari chiqariladi.
Shuni eslatib o'tish kerakki, virtual funksiya faqatgina asos sinfida virtual belgilov bilan o'zgartiriladi, turli sinflarda esa o'zgartirilmasa ham bo'ladi.
3.==2.
4. C++ dasturlash tilida operatorlarni qayta yuklash (operator overloading) tushunchasi, mavjud operatorni sinf obyektlari uchun maxsus ko'rinishda qayta ishlatish imkoniyatini beradi. Bu, kodni oson va qulay tuzilishiga imkon beradi va kodni o'qimasini osonlashtiradi.
Operatorlarni qayta yuklashning bir nechta sabablari mavjud bo'lishi mumkin, masalan:

1. Sinf obyektlari orasida amalga oshirilgan qarshilik ko'rsatkichlarini yaxshilash.


2. Sinf obyektlari uchun maxsus amallar bajarish.
3. Sinflar orasida o'zaro muvofiqlikni oshirish.
Quyidagi misol operatorlarni qayta yuklashni tushunishga yordam beradi:
```c++
#include
using namespace std;

class Complex {


private:
int real;
int imag;

public:
Complex(int r = 0, int i = 0) {


real = r;
imag = i;
}

Complex operator+(Complex const &obj) {


Complex res;
res.real = real + obj.real;
res.imag = imag + obj.imag;
return res;
}

void print() {


cout << real << " + i" << imag << endl;
}
};

int main() {


Complex c1(10, 5), c2(2, 4);
Complex c3 = c1 + c2; // Operator + qayta yuklandi
c3.print();

return 0;


}
```
Bu misolda, `Complex` sinfi yaratilgan va obyektlari `real` va `imag` xususiyatlari bilan aniqlanadi. `operator+` funksiyasi qayta yuklandi va qo'shish amalini bajaradi. `print()` funksiyasi esa obyektni chiqaradi.

`main()` funksiyasida `Complex` sinfi obyektlari yaratiladi va `operator+` funksiyasi chaqiriladi. `c3` o'zgaruvchisiga `c1` va `c2` sinflari qo'shiladi va `print()` funksiyasi chaqiriladi. Natijada, `c3` obyekti `12 + i9` qiymatini chiqaradi.


Boshqa operatorlar (masalan, `-`, `*`, `/`, `++`, `--`, `<<`, `>>`, `==`, `!=`, `>`, `>=`, `<`, `<=` kabi), ham operatorlar qayta yuklanishi mumkin.
5. Namespace – nomlar fasozi
• namespace – bir-xil identifikatorlarni bitta dasturda ishlatish muammosini hal qiladi. namespace ni umumiy strukturasi quyidagicha: • namespace { // o’zgaruvchi va konstantalarni e’lon qilish • } • Name::maydon Namespace ichidagi elementga :: orqali murojaat qilinadi
C++ dasturlash tilida "nomlar fazosi" (namespace) nomi berilgan bir turdir, bu nomlar to'plami xususiyatlari va funksiyalari bitta joyda yig'ishga imkon beradi. Bu yordamda, nomlar fazosi yordamida nomlarni ajratish mumkin va bu nomlar boshqa nomlar fazosidagi nomlardan farq qiladi.

Nomlar fazosi yordamida nomlarni ajratishning bir necha foydalari mavjud:

1. Nomlar fazosi nomlarni organizatsiyalashga imkon beradi va kodni tuzilishini osonlashtiradi.
2. Nomlar fazosi nomlarni qayta ishlatishdan qochiradi, bu esa nomlarning takrorlanishiga olib keladigan xatoliklarni kamaytiradi.
3. Nomlar fazosi nomlarni boshqa nomlar fazosidagi nomlardan farq qiladi, shuning uchun nomlar qayta ishlatilganida xatoliklar paydo bo'lmaydi.

Quyidagi misol nomlar fazosi yordamida nomlarni ajratishni ko'rsatadi:

```c++
#include
using namespace std;

namespace first {


void func() {
cout << "This is first namespace" << endl;
}
} // Birinchi nomlar fazosi tugadi

namespace second {


void func() {
cout << "This is second namespace" << endl;
}
} // Ikkinchi nomlar fazosi tugadi

int main() {


first::func(); // Birinchi nomlar fazosidagi func() funksiyasi ishlatiladi
second::func(); // Ikkinchi nomlar fazosidagi func() funksiyasi ishlatiladi
return 0;
}
```

Bu misolda, "first" va "second" nomlar fazolari yaratiladi. "first" nomlar fazosida "func" nomli funksiya aniqlanadi va "second" nomlar fazosida ham "func" nomli funksiya aniqlanadi. "main" funksiyasida "first" va "second" nomlar fazolaridagi "func" funksiyalari ajratilgan va ularni chaqirishda, funksiyalar nomlar fazosi yordamida chaqiriladi. Natijada, "first" va "second" nomlar fazosidagi "func" funksiyalari konsolga chiqariladi.


6. C++ dasturlash tilida ma'lumot turlarini turdan turga o'tkazish operatorlari yordamida o'zgartirish mumkin. Bunday operatorlar, ma'lumot turlari orasida o'zgarishlarni bajarish uchun ishlatiladi. Masalan, bir turdagi ma'lumotni boshqa turga o'tkazish, o'zgarish qilish, qo'shish yoki boshqa turdagi ma'lumotlar bilan amallar bajarish mumkin.

Quyidagi misol, `int` turidan `double` turiga o'tkazish operatorini ko'rsatadi:

```c++
#include
using namespace std;

class Double {


private:
double value;

public:
Double(double v = 0.0) : value(v) {}

// int turidan Double turiga o'tkazish operatori qayta yuklandi
operator double() {
return value;
}
};

int main() {


int a = 5;
Double b = a; // int turidan Double turiga o'tkaziladi
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
```

Bu misolda, `Double` nomli sinf yaratiladi va `value` nomli xususiyatiga ega bo'lib, `double` turidan obyektlarni yaratish uchun ishlatiladi. `operator double()` qayta yuklandi va `int` turidan `Double` turiga o'tkazish uchun ishlatiladi. `main()` funksiyasida, `a` o'zgaruvchisiga `5` qiymati tayinlangan va `b` o'zgaruvchisiga `a` o'zgaruvchisi o'tkazilgan. Natijada, `a` va `b` qiymatlari konsolga chiqadi.

Boshqa misol:

```c++
#include


using namespace std;

class String {


private:
char *s;

public:
String(const char *str = nullptr) {


if (str == nullptr) {
s = nullptr;
} else {
s = new char[strlen(str) + 1];
strcpy(s, str);
}
}

// char* turidan const char* turiga o'tkazish operatori qayta yuklandi


operator const char *() {
return s;
}
};

int main() {


String s = "Hello, world!"; // char* turidan String turiga o'tkaziladi
const char *str = s; // String turidan const char* turiga o'tkaziladi
cout << "String: " << s << endl;
cout << "const char*: " << str << endl;
return 0;
}
```

Bu misolda, `String` nomli sinf yaratiladi va `s` nomli char tipidagi xususiyati mavjud. `String` sinfida, `const char*` turidan `String` turiga o'tkazish operatori qayta yuklandi. `main()` funksiyasida, `const char*` turidan `String` turiga o'tkazish uchun `s` o'zgaruvchisiga char* turidagi "Hello, world!" qiymati o'tkaziladi. `str` o'zgaruvchisiga `s` o'zgaruvchisi `const char*` turiga o'tkaziladi. Natijada, `s` va `str` qiymatlari konsolga chiqadi.


7. C++ dasturlash tilida, "konteyner" nomi berilgan turli turdagi elementlarni saqlash va boshqarish uchun ishlatiladigan sinflar mavjud. Bu sinflar, bitta turdagi elementlarni boshqa turdagi elementlarga o'zgartirish, qo'shish, o'chirish va qidirish imkonini beradi. Bu konteyner sinflari, standart C++ kutubxonasida mavjud bo'lib, shu jumladan, `vector`, `deque`, `list`, `stack`, `queue` va hokazo. Bularning har biri, o'zining mahsulotini boshqarish uchun xususiy funksiyalarga ega.

Quyidagi misol, `vector` konteyner sinfini ko'rsatadi:

```c++
#include
#include
using namespace std;

int main() {


vector v; // int turidagi vector yaratiladi
v.push_back(1);
v.push_back(2);
v.push_back(3);

cout << "Vector size: " << v.size() << endl; // vektor elementlarini soni


cout << "Vector elements: ";
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `vector` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_back` funksiyasi yordamida, `v` vektoriga 3 ta element qo'shiladi. `size()` funksiyasi yordamida, `v` vektoridagi elementlar soni aniqlanadi va `for` tsikli yordamida, vektordagi elementlar konsolga chiqariladi.

Boshqa misol, `stack` va `queue` konteyner sinflarini ko'rsatadi:

```c++
#include


#include
#include
using namespace std;

int main() {


stack s; // int turidagi stack yaratiladi
s.push(1);
s.push(2);
s.push(3);

cout << "Stack size: " << s.size() << endl; // stack elementlarini soni


cout << "Stack elements: ";
while (!s.empty()) {
cout << s.top() << " ";
s.pop();
}
cout << endl;

queue q; // int turidagi queue yaratiladi


q.push(1);
q.push(2);
q.push(3);

cout << "Queue size: " << q.size() << endl; // queue elementlarini soni


cout << "Queue elements: ";
while (!q.empty()) {
cout << q.front() << " ";
q.pop();
}
cout << endl;

return 0;


}
```
Bu misolda, `stack` va `queue` konteyner sinflari yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `s` stackiga va `q` queue'siga 3 ta element qo'shiladi. `size()` funksiyasi yordamida, `s` va `q` konteynerlaridagi elementlar soni aniqlanadi va `while` tsikli yordamida, konteynerlaridagi elementlar konsolga chiqariladi. `top()` funksiyasi yordamida, `s` stackining eng ustidagi elementi qaytariladi, `front()` funksiyasi yordamida, `q` queue'sining oldindagi elementi qaytariladi va `pop()` funksiyasi yordamida, `s` va `q` konteynerlarining ustidagi elementlar o'chiriladi.
8. C++ dasturlash tilida, "navbat" nomi berilgan turli turdagi amallarni bajarish uchun ishlatiladigan sinflar mavjud. Bu sinflar, o'zlarida qo'shimcha o'zgaruvchilar va funksiyalar saqlash uchun mo'ljallangan. Navbat sinfi, bitta elementni o'zlashtirish, qo'shish va o'chirish imkonini beradi.

Quyidagi misol, `queue` konteyner sinfi yordamida navbatni ko'rsatadi:

```c++
#include
#include
using namespace std;

int main() {


queue q; // string turidagi queue yaratiladi
q.push("John");
q.push("Mike");
q.push("Sarah");

cout << "Queue size: " << q.size() << endl; // queue elementlarini soni


cout << "Queue front: " << q.front() << endl; // queue boshidagi element
cout << "Queue back: " << q.back() << endl; // queue oxirgi element

cout << "Queue elements: ";


while (!q.empty()) {
cout << q.front() << " ";
q.pop();
}
cout << endl;

return 0;


}
```

Bu misolda, `queue` konteyner sinfi yaratiladi va `string` turidagi elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `q` queue'siga 3 ta element qo'shiladi. `size()` funksiyasi yordamida, `q` konteyneridagi elementlar soni aniqlanadi. `front()` funksiyasi yordamida, `q` konteynerining boshidagi elementi qaytariladi. `back()` funksiyasi yordamida, `q` konteynerining oxirgi elementi qaytariladi. `while` tsikli yordamida, `q` konteyneridagi elementlar konsolga chiqariladi va `pop()` funksiyasi yordamida, `q` konteynerining ustidagi elementlar o'chiriladi.

Boshqa misol, `priority_queue` sinfini ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


priority_queue pq; // int turidagi priority queue yaratiladi
pq.push(5);
pq.push(2);
pq.push(10);
pq.push(1);

cout << "Priority queue size: " << pq.size() << endl; // priority queue elementlarini soni


cout << "Priority queue top: " << pq.top() << endl; // priority queue eng yuqori element

cout << "Priority queue elements: ";


while (!pq.empty()) {
cout << pq.top() << " ";
pq.pop();
}
cout << endl;

return 0;


}
```
Bu misolda, `priority_queue` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `pq` priority queue'siga 4 ta element qo'shiladi. `size()` funksiyasi yordamida, `pq` konteynerining elementlar soni aniqlanadi. `top()` funksiyasi yordamida, `pq` konteynerining eng yuqori elementi qaytariladi. `while` tsikli yordamida, `pq` konteyneridagi elementlar konsolga chiqariladi va `pop()` funksiyasi yordamida, `pq` konteynerining ustidagi elementlar o'chiriladi. `priority_queue` sinfi, elementlarini qo'shish va o'chirishda, ularni yuqori darajaga qo'shish tartibi asosida bajaradi.
9. C++ dasturlash tilida, "dek" nomi berilgan turli turdagi ma'lumotlarni saqlash uchun ishlatiladigan sinflar mavjud. "Dek" nomi "double-ended queue" so'zining qisqartmasi hisoblanadi. Bu sinflar, o'zlarida qo'shimcha o'zgaruvchilar va funksiyalar saqlash uchun mo'ljallangan. Dek sinfi, bitta elementni o'zlashtirish, qo'shish va o'chirish imkonini beradi. Shuningdek, bitta elementni dekning boshidan yoki oxiridan o'zlashtirish imkonini ham beradi.

Quyidagi misol, `deque` konteyner sinfi yordamida dekni ko'rsatadi:

```c++
#include
#include
using namespace std;

int main() {


deque d; // int turidagi deque yaratiladi
d.push_back(1);
d.push_back(2);
d.push_front(3);
d.push_front(4);

cout << "Deque size: " << d.size() << endl; // deque elementlarini soni


cout << "Deque front: " << d.front() << endl; // deque boshidagi element
cout << "Deque back: " << d.back() << endl; // deque oxirgi element

cout << "Deque elements: ";


for (int i = 0; i < d.size(); i++) {
cout << d[i] << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `deque` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_back` va `push_front` funksiyalari yordamida, `d` deq'iga 4 ta element qo'shiladi. `size()` funksiyasi yordamida, `d` konteyneridagi elementlar soni aniqlanadi. `front()` funksiyasi yordamida, `d` konteynerining boshidagi elementi qaytariladi. `back()` funksiyasi yordamida, `d` konteynerining oxirgi elementi qaytariladi. `for` tsikli yordamida, `d` konteyneridagi elementlar konsolga chiqariladi.

Boshqa misol, dekni boshidan va oxiridan o'zlashtirish imkonini ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


deque d; // int turidagi deque yaratiladi
d.push_back(1);
d.push_back(2);
d.push_front(3);
d.push_front(4);

cout << "Deque elements from front: ";


while (!d.empty()) {
cout << d.front() << " ";
d.pop_front();
}
cout << endl;

d.push_back(1);


d.push_back(2);
d.push_front(3);
d.push_front(4);

cout << "Deque elements from back: ";


while (!d.empty()) {
cout << d.back() << " ";
d.pop_back();
}
cout << endl;

return 0;


}
```
Bu misolda, `deque` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_back` va `push_front` funksiyalari yordamida, `d` deq'iga 4 ta element qo'shiladi. `while` tsikli yordamida, `d` konteyneri boshidan elementlar o'qiladi va `pop_front()` funksiyasi yordamida, `d` konteynerining ustidagi elementlar o'chiriladi. Keyin, yana `push_back` va `push_front` funksiyalari yordamida, `d` deq'iga 4 ta element qo'shiladi. `while` tsikli yordamida, `d` konteyneri oxiridan elementlar o'qiladi va `pop_back()` funksiyasi yordamida, `d` konteyneriningustidagi elementlar o'chiriladi. Shuningdek, `d` konteyneri chiqish sifatida konsolga chiqariladi. Bu misolda dekni boshidan va oxiridan o'zlashtirish imkonini ko'rsatiladi.
9. C++ dasturlash tilida, "vector" nomi berilgan konteyner sinfi mavjud. Bu sinf elementlarni dinamik ravishda saqlaydi, ya'ni elementlar soni avvaldan aniqlanmasa ham, dastur ishlatilayotgan paytda elementlar soni o'zgartirilishi mumkin.

`vector` sinfi, bitta turdagi elementlarni saqlash uchun ishlatiladi; ana shu turdagi elementlar, ayrim xususiyatlarini saqlab turadi. Misol uchun, int turidagi elementlar `vector` sinfi yordamida saqlanishi mumkin va `push_back` yordamida yangi elementlar qo'shilishi mumkin.

Quyidagi misol, `vector` sinfi yordamida int turidagi elementlarni saqlashni ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


vector v; // int turidagi vector yaratiladi
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);

cout << "Vector size: " << v.size() << endl; // vector elementlarini soni


cout << "Vector elements: ";
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `vector` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_back` funksiyasi yordamida, `v` vectoriga 4 ta element qo'shiladi. `size()` funksiyasi yordamida, `v` konteyneridagi elementlar soni aniqlanadi. `for` tsikli yordamida, `v` konteyneridagi elementlar konsolga chiqariladi.

Boshqa misol, `vector` sinfiga elementlarini boshqa bir `vector`dan nusxalashni ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


vector v1 = {1, 2, 3, 4, 5}; // int turidagi vector yaratiladi
vector v2(v1); // v1 dan nusxa olinadi

cout << "Vector v1 elements: ";


for (int i = 0; i < v1.size(); i++) {
cout << v1[i] << " ";
}
cout << endl;

cout << "Vector v2 elements: ";


for (int i = 0; i < v2.size(); i++) {
cout << v2[i] << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `vector` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `v1` vectoriga 5 ta element qo'shiladi. Keyin, `v2` vectori `v1` dan nusxa olingan. `for` tsikli yordamida, `v1` va `v2` konteyneridagi elementlar konsolga chiqariladi.

Shuningdek, `vector` sinfiga elementlarini qidirish uchun `find` funksiyasini ham ishlatish mumkin. Quyidagi misol, `vector` sinfiga elementlarini qidirishni ko'rsatadi:

```c++
#include


#include
#include
using namespace std;

int main() {


vector v = {5, 3, 6, 1, 2, 4}; // int turidagi vector yaratiladi

int to_find = 3;


auto it = find(v.begin(), v.end(), to_find);

if (it != v.end()) {


cout << "Element found at position: " << it - v.begin() << endl;
}
else {
cout << "Element not found" << endl;
}

return 0;


}
```
Bu misolda, `vector` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `v` vectoriga 6 ta element qo'shiladi. `find` funksiyasi yordamida, `to_find` o'zgaruvchisi qiymati `v` konteynerida qidiriladi. Agar qiymat topilsa, `it` o'zgaruvchisiga topilgan qiymat manzili asign qilinadi, aks holda `it` o'zgaruvchisi `v.end()` manzilini o'zlashtiradi. `if` yordamida, `it` o'zgaruvchisi `v.end()` manziliga teng bo'lmasa, topilgan qiymatning manzili konsolga chiqariladi. Aks holda, "Element not found" xabarini konsolga chiqariladi.
11==9
12. C++ dasturlash tilida, "list" nomi berilgan konteyner sinfi mavjud. Bu sinf, elementlarni o'rtasida bo'shliq (node) bo'lgan yig'indilardan iborat. Har bir element, bir o'ng va chap yonli bo'shliq orqali bir-biriga bog'langan. Bu yig'indilar yordamida, elementlarni o'zgartirish va elementlarni qidirish imkoniyati yuzaga keladi.

Quyidagi misol, `list` konteyner sinfi yordamida int turidagi elementlarni saqlashni va `push_front`, `push_back`, `pop_front` va `pop_back` funksiyalarini ishlatishni ko'rsatadi:

```c++
#include
#include
using namespace std;

int main() {


list l; // int turidagi list yaratiladi
l.push_back(1);
l.push_back(2);
l.push_front(3);
l.push_front(4);

cout << "List size: " << l.size() << endl; // list elementlarini soni


cout << "List front: " << l.front() << endl; // list boshidagi element
cout << "List back: " << l.back() << endl; // list oxirgi element

cout << "List elements: ";


while (!l.empty()) {
cout << l.front() << " ";
l.pop_front();
}
cout << endl;

return 0;


}
```

Bu misolda, `list` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_back` va `push_front` funksiyalari yordamida, `l` listiga 4 ta element qo'shiladi. `size()` funksiyasi yordamida, `l` konteyneridagi elementlar soni aniqlanadi. `front()` funksiyasi yordamida, `l` konteynerining boshidagi elementi qaytariladi. `back()` funksiyasi yordamida, `l` konteynerining oxirgi elementi qaytariladi. `while` tsikli yordamida, `l` konteyneri boshidan elementlar o'qiladi va `pop_front()` funksiyasi yordamida, `l` konteynerining ustidagi elementlar o'chiriladi. Shuningdek, `l` konteyneri chiqish sifatida konsolga chiqariladi.

Boshqa misol, `list` sinfiga elementlarini boshqa bir `list`dan nusxalashni ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


list l1 = {1, 2, 3, 4, 5}; // int turidagi list yaratiladi
list l2(l1); // l1 dan nusxa olinadi

cout << "List l1 elements: ";


while (!l1.empty()) {
cout << l1.front() << " ";
l1.pop_front();
}
cout << endl;

cout << "List l2 elements: ";


while (!l2.empty()) {
cout << l2.front() << " ";
l2.pop_front();
}
cout << endl;

return 0;


}
```

Bu misolda, `list` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `l1` listiga 5 ta element qo'shiladi. Keyin, `l2` list'i `l1` dan nusxa olingan. `while` tsikli yordamida, `l1` va `l2` konteyneridagi elementlar o'qiladi va `pop_front()` funksiyasi yordamida, `l1` va `l2` konteynerining ustidagi elementlar o'chiriladi. Shuningdek, `l1` va `l2` konteynerlari chiqish sifatida konsolga chiqariladi.

Shuningdek, `list` sinfiga elementlariniboshqa bir `list`dan qo'shish va o'chirish misollari quyidagicha bo'lishi mumkin:

```c++
#include


#include
using namespace std;

int main() {


list l1 = {1, 2, 3, 4, 5}; // int turidagi list yaratiladi

// Element qo'shish


l1.push_back(6); // oxiridan 6 qo'shiladi
l1.push_front(0); // oldidan 0 qo'shiladi

// Element o'chirish


l1.pop_back(); // oxirgi element o'chiriladi
l1.pop_front(); // boshidagi element o'chiriladi

// List elementlarini chiqarish


cout << "List elements: ";
for (int x : l1) {
cout << x << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `l1` listiga 5 ta element qo'shiladi. Keyin, `push_back()` va `push_front()` funksiyalari yordamida, `l1` listiga oxiridan 6 va oldidan 0 qo'shiladi. `pop_back()` va `pop_front()` funksiyalari yordamida, `l1` konteynerining oxirgi va boshidagi elementi o'chiriladi. `for` tsikli yordamida, `l1` konteyneridagi elementlar konsolga chiqariladi.

Shuningdek, `list` sinfiga elementlarni qidirish misoli quyidagicha bo'lishi mumkin:

```c++
#include


#include
using namespace std;

int main() {


list l1 = {1, 2, 3, 4, 5}; // int turidagi list yaratiladi

// Elementni topish


auto it = find(l1.begin(), l1.end(), 3); // 3 qiymatini qidiradi
if (it != l1.end()) {
cout << "Element found: " << *it << endl;
} else {
cout << "Element not found" << endl;
}

return 0;


}
Bu misolda, `l1` listiga 5 ta element qo'shiladi. `find()` funksiyasi yordamida, `l1` konteyneridagi 3 qiymatini qidiriladi. Topilgan element `if`-`else` yordamida konsolga chiqariladi.
13. C++ dasturlash tilida, "forward_list" nomi berilgan konteyner sinfi mavjud. Bu sinf, elementlarni boshliq (node) bo'lgan yig'indilardan iborat. Har bir element, faqat bir chap yonli bo'shliq orqali bir-biriga bog'langan. Shuningdek, bu sinf yig'indilarning o'rtasiga kirishga imkon beradi, ammo yig'indilning boshidan yoki oxiridan kirishga imkon bermaydi.

Quyidagi misol, `forward_list` konteyner sinfi yordamida int turidagi elementlarni saqlashni va `push_front`, `pop_front` va `remove` funksiyalarini ishlatishni ko'rsatadi:

```c++
#include
#include
using namespace std;

int main() {


forward_list fl; // int turidagi forward_list yaratiladi
fl.push_front(1);
fl.push_front(2);
fl.push_front(3);
fl.push_front(4);

cout << "Forward list elements: ";


for (int x : fl) {
cout << x << " ";
}
cout << endl;

fl.pop_front(); // boshidagi element o'chiriladi


cout << "Forward list elements after pop_front(): ";
for (int x : fl) {
cout << x << " ";
}
cout << endl;

fl.remove(3); // 3 qiymatini o'chiradi


cout << "Forward list elements after remove(3): ";
for (int x : fl) {
cout << x << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `forward_list` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `push_front` funksiyasi yordamida, `fl` forward_listiga 4 ta element qo'shiladi. `for` tsikli yordamida, `fl` konteyneridagi elementlar konsolga chiqariladi. `pop_front()` funksiyasi yordamida, `fl` konteynerining boshidagi elementi o'chiriladi. `remove()` funksiyasi yordamida, `fl` konteyneridagi 3 qiymatli element o'chiriladi. `for` tsikl yordamida, `fl` konteyneridagi elementlar konsolga chiqariladi.

Boshqa bir misol, `forward_list` sinfiga elementlarini boshqa bir `forward_list`dan nusxalashni ko'rsatadi:

```c++
#include


#include
using namespace std;

int main() {


forward_list fl1 = {1, 2, 3, 4, 5}; // int turidagi forward_list yaratiladi
forward_list fl2(fl1); // fl1 dan nusxa olinadi

cout << "Forward list fl1 elements: ";


for (int x : fl1) {
cout << x << " ";
}
cout << endl;

cout << "Forward list fl2 elements: ";


for (int x : fl2) {
cout << x << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `forward_list` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `fl1` forward_listiga 5 ta element qo'shiladi. Keyin, `fl2` forward_list'i `fl1` dan nusxa olingan. `for` tsikli yordamida, `fl1` va `fl2` konteyneridagi elementlar konsolga chiqariladi.

Shuningdek, `forward_list` sinfiga elementlarini qidirish misoli quyidagicha bo'lishi mumkin:

```c++
#include


#include
using namespace std;

int main() {


forward_list fl1 = {1, 2, 3, 4, 5}; // int turidagi forward_list yaratiladi

// Elementni topish


auto it =fl1.begin(); // Forward listning boshidan boshlab qidirishni boshlaymiz
while (it != fl1.end()) {
if (*it == 3) { // Agar element 3 ga teng bo'lsa ...
cout << "Element 3 is found!" << endl;
break; // Qidirishni to'xtatamiz
}
++it; // Keyingi elementga o'tish
}

// Agar element topilmasa


if (it == fl1.end()) {
cout << "Element 3 is not found!" << endl;
}

return 0;


}
```
Bu misolda, `forward_list` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `fl1` forward_listiga 5 ta element qo'shiladi. Keyin, `it` iteratori yordamida, `fl1` konteyneridagi elementlar qidiriladi. Agar qidirilayotgan element topilmasa, konsolga "Element 3 is not found!" xabar chiqariladi. Aks holda, "Element 3 is found!" xabar chiqariladi.
14. C++ dasturlash tilida, "set" nomi berilgan konteyner sinfi mavjud. Bu sinf, biror turdagi elementlarni bitta buyruq asosida saralash uchun ishlatiladi. Set sinfi yozilgan elementlarni avtomatik ravishda saralaydi va har bir element faqat bir martta mavjud bo'ladi.

Quyidagi misol, `set` konteyner sinfi yordamida string turidagi elementlarni saqlashni va `insert`, `erase` va `find` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


set mySet; // string turidagi set yaratiladi
mySet.insert("apple");
mySet.insert("banana");
mySet.insert("orange");
mySet.insert("kiwi");

cout << "Set elements: ";


for (string x : mySet) {
cout << x << " ";
}
cout << endl;

mySet.erase("orange"); // "orange" o'chiriladi


cout << "Set elements after erase(): ";
for (string x : mySet) {
cout << x << " ";
}
cout << endl;

auto it = mySet.find("banana"); // "banana" elementni qidirish


if (it != mySet.end()) {
cout << "Element found in set: " << *it << endl;
} else {
cout << "Element not found in set." << endl;
}

return 0;


}
```

Bu misolda, `set` konteyner sinfi yaratiladi va `string` turidagi elementlarni saqlash uchun ishlatiladi. `insert` funksiyasi yordamida, `mySet` setiga 4 ta element qo'shiladi. `for` tsikli yordamida, `mySet` konteyneridagi elementlar konsolga chiqariladi. "orange" qiymatli element `erase()` yordamida o'chiriladi. `for` tsikli yordamida, `mySet` konteyneridagi elementlar konsolga chiqariladi. `find()` funksiyasi yordamida, `mySet` konteyneridagi "banana" qiymatli element qidiriladi. Agar topilsa, konsolga "Element found in set: banana" xabar chiqariladi. Aks holda, "Element not found in set." xabar chiqariladi.


Boshqa bir misol, `set` sinfiga elementlarini boshqa bir `set`dan nusxalashni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


set set1 = {1, 2, 3, 4, 5}; // int turidagi set yaratiladi
set set2(set1); // set1 dan nusxa olinadi

cout << "Set set1 elements: ";


for (int x : set1) {
cout << x << " ";
}
cout << endl;

cout << "Set set2 elements: ";


for (int x : set2) {
cout << x << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `set` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `set1` setiga 5 ta element qo'shiladi. Keyin, `set2` set'i `set1` dan nusxa olingan. `for` tsikli yordamida, `set1` va `set2` konteyneridagi elementlar konsolga chiqariladi.


Set sinfi yordamida avtomatik ravishda saralash va elementlar faqat bir martta mavjud bo'lish tufayli, uning ishlatilishi juda qulaydir. Misol uchun, biror turdagi elementlarni saralash va ularning qidirishini amalga oshirish uchun `set` sinfi juda foydali bo'ladi.


15. C++ dasturlash tilida, "multiset" nomi berilgan konteyner sinfi mavjud. Bu sinf, `set` sinfiga o'xshash funktsionalni o'z ichiga oladi, ammo biror turdagi elementlarni shunchaki saralashga emas, balki biror turdagi elementlarni ko'p qo'llanishiga imkon beradi. Boshqa so'z bilan, biror turdagi bir nechta elementlarni saqlash uchun ishlatiladi.

Quyidagi misol, `multiset` konteyner sinfi yordamida string turidagi elementlarni saqlashni va `insert`, `erase` va `count` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


multiset myMultiset; // string turidagi multiset yaratiladi
myMultiset.insert("apple");
myMultiset.insert("banana");
myMultiset.insert("orange");
myMultiset.insert("banana");
myMultiset.insert("kiwi");

cout << "Multiset elements: ";


for (string x : myMultiset) {
cout << x << " ";
}
cout << endl;

myMultiset.erase("banana"); // "banana" ni o'chirish


cout << "Multiset elements after erase(): ";
for (string x : myMultiset) {
cout << x << " ";
}
cout << endl;

int count = myMultiset.count("banana"); // "banana" elementni sanash


cout << "Number of bananas in multiset: " << count << endl;

return 0;


}
```

Bu misolda, `multiset` konteyner sinfi yaratiladi va `string` turidagi elementlarni saqlash uchun ishlatiladi. `insert` funksiyasi yordamida, `myMultiset` multisetiga 5 ta element qo'shiladi. `for` tsikli yordamida, `myMultiset` konteyneridagi elementlar konsolga chiqariladi. "banana" qiymatli element `erase()` yordamida o'chiriladi. `for` tsikli yordamida, `myMultiset` konteyneridagi elementlar konsolga chiqariladi. `count()` funksiyasi yordamida, `myMultiset` konteyneridagi "banana" qiymatli elementlar soni hisoblanadi va konsolga chiqariladi.


Boshqa bir misol, `multiset` sinfiga elementlarini boshqa bir `multiset`dan nusxalashni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


multiset multiset1 = {1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5}; // int turidagi multiset yaratiladi
multiset multiset2(multiset1); // multiset1 dan nusxa olinadi

cout << "Multiset multiset1 elements: ";


for (int x : multiset1) {
cout << x << " ";
}
cout << endl;

cout << "Multiset multiset2 elements: ";


for (int x : multiset2) {
cout << x << " ";
}
cout << endl;

return 0;


}
```
Bu misolda, `multiset` konteyner sinfi yaratiladi va `int` turidagi elementlarni saqlash uchun ishlatiladi. `multiset1` multisetiga 11 ta element qo'shiladi. Keyin, `multiset2` multiset'i `multiset1` dan nusxa olingan. `for` tsikli yordamida, `multiset1` va `multiset2` konteyneridagi elementlar konsolga chiqariladi.
`multiset` sinfi, biror turdagi bir nechta elementlarni saqlash uchun ishlatiladi. Ushbu sinf yordamida, biror turdagi elementlarni ko'p qo'llash mumkin. Misol uchun, biror turdagi elementlarning sanashini yoki ularning ko'p nusxalarini saqlash uchun foydali bo'ladi.
16. C++ dasturlash tilida, "map" nomi berilgan konteyner sinfi mavjud. Bu sinf, biror turdagi elementlarni bitta kalit bilan biriktirish uchun ishlatiladi. Kalitlar unikal bo'ladi, yani har bir kalit faqat bitta elementga mos keladi.

Quyidagi misol, `map` konteyner sinfi yordamida string kalit va int qiymatli elementlarni saqlashni va `insert`, `erase` va `find` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


map myMap; // string kalit va int qiymatli elementlarni saqlash uchun map yaratiladi
myMap.insert({"apple", 10});
myMap.insert({"banana", 20});
myMap.insert({"orange", 30});
myMap.insert({"kiwi", 40});

cout << "Map elements: ";


for (auto x : myMap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

myMap.erase("orange"); // "orange" ni o'chirish


cout << "Map elements after erase(): ";
for (auto x : myMap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

auto it = myMap.find("banana"); // "banana" elementni qidirish


if (it != myMap.end()) {
cout << "Element found in map: {" << it->first << ", " << it->second << "}" << endl;
} else {
cout << "Element not found in map." << endl;
}

return 0;


}
```

Bu misolda, `map` konteyner sinfi yaratiladi va `string` kalit va `int` qiymatli elementlarni saqlash uchun ishlatiladi. `insert` funksiyasi yordamida, `myMap` mapiga 4 ta element qo'shiladi. `for` tsikli yordamida, `myMap` konteyneridagi elementlar konsolga chiqariladi. "orange" qiymatli element `erase()` yordamida o'chiriladi. `for` tsikli yordamida, `myMap` konteyneridagi elementlar konsolga chiqariladi. `find()` funksiyasi yordamida, `myMap` konteynerida "banana" kalitli element qidiriladi. Agar topilsa, konsolga "Element found in map: {banana, 20}" xabar chiqariladi. Aks holda, "Element not found in map." xabar chiqariladi.


Boshqa bir misol, `map` sinfiga elementlarini boshqa bir `map`dan nusxalashni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


map map1 = {{"apple", 10}, {"banana", 20}, {"orange", 30}, {"kiwi", 40}}; // string kalit va int qiymatli elementlarni saqlash uchun map yaratiladi
map map2(map1); // map1 dan nusxa olinadi

cout << "Map map1 elements: ";


for (auto x : map1) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

cout << "Map map2 elements: ";


for (auto x : map2) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

return 0;


}
```

Bu misolda, `map` konteyner sinfi yaratiladi va `string` kalit va `int` qiymatli elementlarni saqlash uchun ishlatiladi. `map1` mapiga 4 ta element qo'shiladi. Keyin, `map2` map'i `map1` dan nusxa olingan. `for` tsikli yordamida, `map1` va `map2` konteyneridagi elementlar konsolga chiqariladi.


`map` sinfi, biror turdagi kalit-qiymat juftliklarini saqlash uchun ishlatiladi. Ushbu sinf yordamida, kalitlar unikal bo'ladi va har bir kalit faqat bitta elementga mos keladi. Misol uchun, biror turdagi elementlar uchun kalitlar va ularning qiymatlari saqlash uchun foydali bo'ladi.
17. C++ dasturlash tilida, "multimap" nomi berilgan konteyner sinfi mavjud. Bu sinf, biror turdagi elementlarni bitta kalit bilan biriktirish uchun ishlatiladi, ammo biror kalitga ko'p qiymatlar mos kelishi mumkin. Kalitlar unikal bo'lmasa ham ma'lum elementga mos kelishi mumkin.

Quyidagi misol, `multimap` konteyner sinfi yordamida string kalit va int qiymatli elementlarni saqlashni va `insert`, `erase` va `find` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


multimap myMultimap; // string kalit va int qiymatli elementlarni saqlash uchun multimap yaratiladi
myMultimap.insert({"apple", 10});
myMultimap.insert({"banana", 20});
myMultimap.insert({"orange", 30});
myMultimap.insert({"banana", 40});
myMultimap.insert({"kiwi", 50});

cout << "Multimap elements: ";


for (auto x : myMultimap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

auto it = myMultimap.find("banana"); // "banana" elementni qidirish


if (it != myMultimap.end()) {
cout << "Element found in multimap: {" << it->first << ", " << it->second << "}" << endl;
} else {
cout << "Element not found in multimap." << endl;
}

myMultimap.erase("banana"); // "banana" elementlarni o'chirish


cout << "Multimap elements after erase(): ";
for (auto x : myMultimap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

return 0;


}
```

Bu misolda, `multimap` konteyner sinfi yaratiladi va `string` kalit va `int` qiymatli elementlarni saqlash uchun ishlatiladi. `insert` funksiyasi yordamida, `myMultimap` multimapiga 5 ta element qo'shiladi. `for` tsikli yordamida, `myMultimap` konteyneridagi elementlar konsolga chiqariladi. "banana" qiymatli element `erase()` yordamida o'chiriladi. `for` tsikli yordamida, `myMultimap` konteyneridagi elementlar konsolga chiqariladi. `find()` funksiyasi yordamida, `myMultimap` konteynerida "banana" kalitli element qidiriladi. Bu yerda, "banana" kaliti ikkita qiymat bilan bir nechta marta saqlanganligi uchun, `find()` funksiyasi faqat birinchi kiritilgan "banana" elementini topadi. Agar topilsa, konsolga "Element found in multimap: {banana, 20}" xabar chiqariladi. Aks holda, "Element not found in multimap." xabar chiqariladi.


Boshqa bir misol, `multimap` sinfiga elementlarini boshqa bir `multimap`dan nusxalashni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


multimap multimap1 = {{"apple", 10}, {"banana", 20}, {"orange", 30}, {"banana", 40}, {"kiwi", 50}}; // string kalit va int qiymatli elementlarni saqlash uchun multimap yaratiladi
multimap multimap2(multimap1); // multimap1 dan nusxa olinadi

cout << "Multimap multimap1 elements: ";


for (auto x : multimap1) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

cout << "Multimap multimap2 elements: ";


for (auto x : multimap2) {
cout << "{" << x.first << ", " << xMultimap sinfi, biror turdagi kalit-qiymat juftliklarini saqlash uchun ishlatiladi. Bu sinf, kalitlar unikal bo'lmasa ham, biror kalitga ko'p qiymatlar mos kelishi mumkin. Misol uchun, biror turdagi elementlar uchun bir nechta qiymatlar saqlash uchun foydali bo'ladi.

Quyidagi misol, `multimap` konteyner sinfi yordamida string kalit va int qiymatli elementlarni saqlashni va `insert`, `erase` va `find` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


multimap myMultimap; // string kalit va int qiymatli elementlarni saqlash uchun multimap yaratiladi
myMultimap.insert({"apple", 10});
myMultimap.insert({"banana", 20});
myMultimap.insert({"orange", 30});
myMultimap.insert({"banana", 40});
myMultimap.insert({"kiwi", 50});

cout << "Multimap elements: ";


for (auto x : myMultimap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

auto it = myMultimap.find("banana"); // "banana" elementni qidirish


if (it != myMultimap.end()) {
cout << "Element found in multimap: {" << it->first << ", " << it->second << "}" << endl;
} else {
cout << "Element not found in multimap." << endl;
}

myMultimap.erase("banana"); // "banana" elementlarni o'chirish


cout << "Multimap elements after erase(): ";
for (auto x : myMultimap) {
cout << "{" << x.first << ", " << x.second << "} ";
}
cout << endl;

return 0;


}
```

Bu misolda, `multimap` konteyner sinfi yaratiladi va `string` kalit va `int` qiymatli elementlarni saqlash uchun ishlatiladi. `insert` funksiyasi yordamida, `myMultimap` multimapiga 5 ta element qo'shiladi. `for` tsikli yordamida, `myMultimap` konteyneridagi elementlar konsolga chiqariladi. "banana" qiymatli element `erase()` yordamida o'chiriladi. `for` tsikli yordamida, `myMultimap` konteyneridagi elementlar konsolga chiqariladi. `find()` funksiyasi yordamida, `myMultimap` konteynerida "banana" kalitli element qidiriladi. Bu yerda, "banana" kaliti ikkita qiymat bilan bir nechta marta saqlanganligi uchun, `find()` funksiyasi faqat birinchi kiritilgan "banana" elementini topadi. Agar topilsa, konsolga "Element found in multimap: {banana, 20}" xabar chiqariladi. Aks holda, "Element not found in multimap." xabar chiqariladi.


18. C++ dasturlash tilida, "stack" nomi berilgan konteyner sinfi mavjud. Bu sinf, LIFO (Last In, First Out) prinsipi asosida elementlarni saqlash uchun ishlatiladi. Ya'ni, eng oxirgi kiritilgan element birinchi chiqadi.


Quyidagi misol, `stack` konteyner sinfi yordamida integer qiymatli elementlarni saqlashni va `push`, `pop` va `top` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


stack myStack; // integer qiymatli elementlarni saqlash uchun stack yaratiladi
myStack.push(10);
myStack.push(20);
myStack.push(30);

cout << "Stack elements: ";


while (!myStack.empty()) { // stack bo'sh bo'lmasa
cout << myStack.top() << " "; // stackning yuqori elementi konsolga chiqariladi
myStack.pop(); // stackning yuqori elementi o'chiriladi
}
cout << endl;

return 0;


}
```

Bu misolda, `stack` konteyner sinfi yaratiladi va integer qiymatli elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `myStack` stackiga 3 ta element qo'shiladi. `while` tsikli yordamida, stack bo'sh bo'lmasa, `top()` funksiyasi yordamida, stackning yuqori elementi konsolga chiqariladi va `pop()` funksiyasi yordamida, stackning yuqori elementi o'chiriladi.


Boshqa bir misol, `stack` sinfiga matn qiymatli elementlarni saqlashni va `push`, `pop` va `top` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
#include
using namespace std;

int main() {


stack myStack; // matn qiymatli elementlarni saqlash uchun stack yaratiladi
myStack.push("apple");
myStack.push("banana");
myStack.push("orange");

cout << "Stack elements: ";


while (!myStack.empty()) { // stack bo'sh bo'lmasa
cout << myStack.top() << " "; // stackning yuqori elementi konsolga chiqariladi
myStack.pop(); // stackning yuqori elementi o'chiriladi
}
cout << endl;

return 0;


}
```

Bu misolda, `stack` konteyner sinfi yaratiladi va matn qiymatli elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `myStack` stackiga 3 ta element qo'shiladi. `while` tsikli yordamida, stack bo'sh bo'lmasa, `top()` funksiyasi yordamida, stackning yuqori elementi konsolga chiqariladi va `pop()` funksiyasi yordamida, stackning yuqori elementi o'chiriladi.


19. C++ dasturlash tilida, "queue" nomi berilgan konteyner sinfi mavjud. Bu sinf, FIFO (First In, First Out) prinsipi asosida elementlarni saqlash uchun ishlatiladi. Ya'ni, eng birinchi kiritilgan element birinchi chiqadi.

Quyidagi misol, `queue` konteyner sinfi yordamida integer qiymatli elementlarni saqlashni va `push`, `pop` va `front` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
using namespace std;

int main() {


queue myQueue; // integer qiymatli elementlarni saqlash uchun queue yaratiladi
myQueue.push(10);
myQueue.push(20);
myQueue.push(30);

cout << "Queue elements: ";


while (!myQueue.empty()) { // queue bo'sh bo'lmasa
cout << myQueue.front() << " "; // queuening oldingi elementi konsolga chiqariladi
myQueue.pop(); // queuening oldingi elementi o'chiriladi
}
cout << endl;

return 0;


}
```

Bu misolda, `queue` konteyner sinfi yaratiladi va integer qiymatli elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `myQueue` queue'ga 3 ta element qo'shiladi. `while` tsikli yordamida, queue bo'sh bo'lmasa, `front()` funksiyasi yordamida, queuening oldingi elementi konsolga chiqariladi va `pop()` funksiyasi yordamida, queuening oldingi elementi o'chiriladi.


Boshqa bir misol, `queue` sinfiga matn qiymatli elementlarni saqlashni va `push`, `pop` va `front` funksiyalarini ishlatishni ko'rsatadi:


```c++
#include


#include
#include
using namespace std;

int main() {


queue myQueue; // matn qiymatli elementlarni saqlash uchun queue yaratiladi
myQueue.push("apple");
myQueue.push("banana");
myQueue.push("orange");

cout << "Queue elements: ";


while (!myQueue.empty()) { // queue bo'sh bo'lmasa
cout << myQueue.front() << " "; // queuening oldingi elementi konsolga chiqariladi
myQueue.pop(); // queuening oldingi elementi o'chiriladi
}
cout << endl;

return 0;


}
```

Bu misolda, `queue` konteyner sinfi yaratiladi va matn qiymatli elementlarni saqlash uchun ishlatiladi. `push` funksiyasi yordamida, `myQueue` queue'ga 3 ta element qo'shiladi. `while` tsikli yordamida, queue bo'sh bo'lmasa, `front()` funksiyasi yordamida, queuening oldingi elementi konsolga chiqariladi va `pop()` funksiyasi yordamida, queuening oldingi elementi o'chiriladi.


20. Iterator, konteyner sinfida joylashgan elementlarga o'zaro aloqani yopish uchun ishlatiladigan obyekt sifatida tanimlanadi. Iterator, konteyner sinfi elementlarini yozish va o'qish uchun xizmat qiladi.

Iteratorlar, barcha standart C++ konteyner sinflari uchun ishlatiladi. Asosiy iterator turlari quyidagilardir:


- Input iterator: Bu iteratorlar, konteyner sinfi elementlarini faqatgina o'qish uchun ishlatiladi. Misol uchun, `cin` yordamida kiritilgan ma'lumotlarni o'qish uchun ishlatiladi.


- Output iterator: Bu iteratorlar, konteyner sinfi elementlarini faqatgina yozish uchun ishlatiladi. Misol uchun, faylga yozish uchun ishlatiladi.


- Forward iterator: Bu iteratorlar, konteyner sinfi elementlarini o'qish va yozish uchun ishlatiladi. Misol uchun, `list` konteyner sinfi uchun ishlatiladi.


- Bidirectional iterator: Bu iteratorlar, konteyner sinfi elementlarini boshidan oxiriga yoki oxiridan boshiga o'qish va yozish uchun ishlatiladi. Misol uchun, `set` va `map` konteyner sinflari uchun ishlatiladi.


- Random access iterator: Bu iteratorlar, konteyner sinfi elementlariga indeks orqali murojat qilish uchun ishlatiladi. Misol uchun, `vector` va `deque` konteyner sinflari uchun ishlatiladi.


Quyidagi misol, `vector` konteyner sinfiga `for` tsikli yordamida murojat qilib, elementlarni konsolga chiqaradi:


```c++
#include


#include
using namespace std;

int main() {


vector myVector = {1, 2, 3, 4, 5};

cout << "Vector elements: ";


for (vector::iterator it = myVector.begin(); it != myVector.end(); ++it) {
cout << *it << " ";
}
cout << endl;

return 0;


}
```

Bu misolda, `vector` konteyner sinfi yaratiladi va integer qiymatli elementlar bilan to'ldiriladi. `for` tsikli yordamida, iterator yaratiladi va `begin()` funksiyasi yordamida, `myVector` vektoring boshidan boshlanadi. `end()` funksiyasi yordamida, `myVector` vektoring oxiridan o'tiladi. `it` iteratori, tsikl boshida `begin()` funksiyasi orqali olinadi va tsikl tugaguncha o'sha iterator `end()` funksiyasi bilan solishtiriladi. Tsikl ichida, iteratorning yordamida vektorning har bir elementi konsolga chiqariladi.


Boshqa bir misol, `set` konteyner sinfiga `while` tsikli yordamida murojat qilib, elementlarni konsolga chiqaradi:


```c++
#include


#include
using namespace std;

int main() {


set mySet = {"apple", "banana", "orange"};

cout << "Set elements: ";


set::iterator it = mySet.begin();
while (it != mySet.end()) {
cout << *it << " ";
++it;
}
cout << endl;

return 0;


}
```

Bu misolda, `set` konteyner sinfi yaratiladi va matn qiymatli elementlar bilan to'ldiriladi. `while` tsikli yordamida, iterator yaratiladi va `begin()` funksiyasi yordamida, `mySet` setining boshidan boshlanadi. `end()` funksiyasi yordamida, `mySet` setining oxiridan o'tiladi. `it` iteratori, tsikl boshida `begin()` funksiyasi orqali olinadi va tsikl tugaguncha o'sha iterator `end()` funksiyasi bilan solishtiriladi. Tsikl ichida, iteratorning yordamida setning har bir elementi konsolga chiqariladi.


21. `malloc` (Memory Allocation) C/C++ dasturlash tillarida, dinamik xotiralarni ajratish uchun ishlatiladigan funksiya. Bu funksiya, hafizaning hajmini o'zgartirishga yordam beradi va bitta yoki bir necha elementlarga aloqani yopadi.

`malloc` funksiyasi, hafiza ajratish uchun ishlatiladi va xotiraning hajmini o'zgartirishga yordam beradi. Bu funksiya yordamida, siz o'zgaruvchini yaratishingiz va uni kerakli hajmda aloqaga olib, bu o'zgaruvchiga o'z xohish etgan qiymatni yuklash imkoniyatiga ega bo'lasiz.


Quyidagi misol, `malloc` funksiyasi yordamida integer qiymatli hafiza blokini ajratishni ko'rsatadi:


```c++
#include


#include

int main() {


int* ptr;
int n, i, sum = 0;

printf("Enter number of elements: ");


scanf("%d", &n);

ptr = (int*)malloc(n * sizeof(int)); // n ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (ptr == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter elements: ");


for (i = 0; i < n; ++i) {
scanf("%d", ptr + i);
sum += *(ptr + i);
}

printf("Sum = %d", sum);


free(ptr); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `malloc` funksiyasi yordamida, `n` ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar `scanf` yordamida olinadi va hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.


Boshqa bir misol, `malloc` funksiyasi yordamida matn qiymatli hafiza blokini ajratishni ko'rsatadi:


```c++
#include


#include
#include

int main() {


char* str;
int size;

printf("Enter size of string: ");


scanf("%d", &size);

str = (char*)malloc(size * sizeof(char)); // size ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (str == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter a string: ");


scanf(" ");
gets(str);

printf("Entered string is: %s", str);


free(str); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```

Bu misolda, foydalanuvchi matn qiymatli elementlar hajmini kiritadi. `malloc` funksiyasi yordamida, `size` ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `gets` funksiyasi yordamida, foydalanuvchi tomonidan kiritilgan matn qiymatli elementlar hafizaga yoziladi. `printf` yordamida, hafizagayozilgan matn qiymati konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.


22. `calloc` (Contiguous Allocation) C/C++ dasturlash tillarida, dinamik xotiralarni ajratish uchun ishlatiladigan funksiya. Bu funksiya, hafizaning hajmini o'zgartirishga yordam beradi va bitta yoki bir necha elementlarga aloqani yopadi. `malloc` bilan bir xil ishni bajaradi, ammo `malloc`dan farq qiladi. `calloc` funksiyasi yordamida, ajratilayotgan hafiza blokining hajmi, elementlar soni va har bir element uchun olcham ko'rinishida kiritilishi mumkin. `calloc` funksiyasi yordamida ajratilgan hafiza bloki, 0 qiymatiga ega bo'ladi.

Quyidagi misol, `calloc` funksiyasi yordamida integer qiymatli hafiza blokini ajratishni ko'rsatadi:


```c++
#include


#include

int main() {


int* ptr;
int n, i, sum = 0;

printf("Enter number of elements: ");


scanf("%d", &n);

ptr = (int*)calloc(n, sizeof(int)); // n ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (ptr == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter elements: ");


for (i = 0; i < n; ++i) {
scanf("%d", ptr + i);
sum += *(ptr + i);
}

printf("Sum = %d", sum);


free(ptr); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `calloc` funksiyasi yordamida, `n` ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar `scanf` yordamida olinadi va hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.


Boshqa bir misol, `calloc` funksiyasi yordamida matn qiymatli hafiza blokini ajratishni ko'rsatadi:


```c++
#include


#include
#include

int main() {


char* str;
int size;

printf("Enter size of string: ");


scanf("%d", &size);

str = (char*)calloc(size, sizeof(char)); // size ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (str == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter a string: ");


scanf(" ");
gets(str);

printf("Entered string is: %s", str);


free(str); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```
Bu misolda, foydalanuvchi matn qiymatli elementlar hajmini kiritadi. `calloc` funksiyasi yordamida, `size` ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `gets` funksiyasi yordamida, foydalanuvchi tomonidan kiritilgan matn qiymatli elementlar hafizaga yoziladi. `printf` yordamida, hafizagayyozilgan matn qiymati konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.
23. Vallaray sonli sinflar va funksiyalar, C++ dasturlash tillarida ishlatiladigan vektorlar va dinamik massivlar kabi o'zgaruvchilarni ishlab chiqish uchun yaxshi imkoniyatlar beradi.

Vallaray sonli sinflar, o'z ichiga o'zgaruvchilarni saqlash uchun dinamik hafiza ajratish uchun yaxshi usuldir. Vallaray sonli sinflar, `vector` sinfi kabi mavjud sinflardan foydalanish orqali yaratilishi mumkin.


Quyidagi misol, `vector` sinfi yordamida integer qiymatli elementlarni saqlashni ko'rsatadi:


```c++
#include


#include

using namespace std;


int main() {


vector v;
int n, i, sum = 0;

cout << "Enter number of elements: ";


cin >> n;

cout << "Enter elements: ";


for (i = 0; i < n; ++i) {
int x;
cin >> x;
v.push_back(x);
}

for (i = 0; i < n; ++i) {


sum += v[i];
}

cout << "Sum = " << sum;


return 0;


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `vector` sinfi yordamida, `n` ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar `push_back` yordamida hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi.


Vallaray sonli funksiyalar, `malloc` va `calloc` funksiyalari kabi dinamik hafizani ajratish uchun yaxshi usuldir. Bu funksiyalar yordamida, hafiza aloqasi ajratiladi va to'plamlar, matnlar va boshqa obyektlar kabi elementlar saqlanishi mumkin.


Quyidagi misol, `malloc` yordamida integer qiymatli elementlarni saqlashni ko'rsatadi:


```c++
#include


#include

int main() {


int* ptr;
int n, i, sum = 0;

printf("Enter number of elements: ");


scanf("%d", &n);

ptr = (int*)malloc(n * sizeof(int)); // n ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (ptr == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter elements: ");


for (i = 0; i < n; ++i) {
scanf("%d", ptr + i);
sum += *(ptr + i);
}

printf("Sum = %d", sum);


free(ptr); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `malloc` funksiyasi yordamida, `n` ta integer qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar `scanf` yordamida olinadi va hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.


Quyidagi misol, `calloc` yordamida matn qiymatli elementlarni saqlashni ko'rsatadi:


```c++
#include


#include
#include

int main() {


char* str;
int size;

printf("Enter size of string: ");


scanf("%d", &size);

str = (char*)calloc(size, sizeof(char)); // size ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratish


if (str == NULL) {
printf("Error! Memory not allocated.");
exit(0);
}

printf("Enter a string: ");


scanf(" ");
gets(str);

printf("Entered string is: %s", str);


free(str); // ajratilgan hafiza blokini bo'shatish

return 0;


}
```

Bu misolda, foydalanuvchi matn qiymatli elementlar hajmini kiritadi. `calloc` funksiyasi yordamida, `size` ta char qiymatli elementlarni saqlash uchun hafiza blokini ajratiladi. `if` sharti yordamida, ajratilgan hafiza blokining tuzatilmaganligini tekshirishga imkon beriladi. `gets` funksiyasi yordamida, foydalanuvchi tomonidan kiritilgan matn qiymatli elementlar hafizaga yoziladi. `printf` yordamida, hafizagayyozilgan matn qiymati konsolga chiqariladi. `free` funksiyasi yordamida, ajratilgan hafiza bo'shatiladi.


24. Slice, Go dasturlash tilida ishlatiladigan bir turi ro'yxatdir. Slice, dinamik massivlar uchun Go tilining asosiy turidir va ro'yxat elementlarining bir qismidan yoki barchasidan foydalanish imkoniyatini beradi.

Quyidagi misol, slice yordamida integer qiymatli elementlarni saqlashni ko'rsatadi:


```go
package main


import "fmt"


func main() {


var s []int
var n, i, sum int

fmt.Print("Enter number of elements: ")


fmt.Scan(&n)

s = make([]int, n) // n ta integer qiymatli elementlarni saqlash uchun slice yaratish


fmt.Print("Enter elements: ")


for i = 0; i < n; i++ {
fmt.Scan(&s[i])
sum += s[i]
}

fmt.Println("Sum =", sum)


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `make` yordamida, `n` ta integer qiymatli elementlarni saqlash uchun slice yaratiladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar slice yordamida hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi.


Quyidagi misol, slice yordamida matn qiymatli elementlarni saqlashni ko'rsatadi:


```go
package main


import "fmt"


func main() {


var s []string
var n, i int

fmt.Print("Enter number of elements: ")


fmt.Scan(&n)

s = make([]string, n) // n ta matn qiymatli elementlarni saqlash uchun slice yaratish


fmt.Print("Enter elements: ")


for i = 0; i < n; i++ {
fmt.Scan(&s[i])
}

fmt.Println("Entered elements are:")


for i = 0; i < n; i++ {
fmt.Println(s[i])
}
}
```
Bu misolda, foydalanuvchi matn qiymatli elementlar sonini kiritadi. `make` yordamida, `n` ta matn qiymatli elementlarni saqlash uchun slice yaratiladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar slice yordamida hafizaga yoziladi. `fmt.Println` yordamida, hafizaga yozilgan matn qiymati konsolga chiqariladi.
25. Golang'da `gslice` diye bir veri tipi yoktur, ancak `slice` veri tipi Go'nun temel veri tiplerinden biridir. Golang'da slice'lar, Go'nun dinamik veri türlerinden biridir ve Go'nun diğer temel veri tipleri gibi tamamen özelleştirilebilirler. Slice'lar, Go programlama dilinde dizilerin geliştirilmiş bir türü olarak düşünülebilir.

Quyidagi misol, slice yordamida integer qiymatli elementlarni saqlashni ko'rsatadi:


```go
package main


import "fmt"


func main() {


var s []int
var n, i, sum int

fmt.Print("Enter number of elements: ")


fmt.Scan(&n)

s = make([]int, n) // n ta integer qiymatli elementlarni saqlash uchun slice yaratish


fmt.Print("Enter elements: ")


for i = 0; i < n; i++ {
fmt.Scan(&s[i])
sum += s[i]
}

fmt.Println("Sum =", sum)


}
```

Bu misolda, foydalanuvchi integer qiymatli elementlar sonini kiritadi. `make` yordamida, `n` ta integer qiymatli elementlarni saqlash uchun slice yaratiladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar slice yordamida hafizaga yoziladi. `sum` o'zgaruvchi yordamida, hafizaga yozilgan elementlar yig'indisini hisoblangan holda konsolga chiqariladi.


Quyidagi misol, slice yordamida matn qiymatli elementlarni saqlashni ko'rsatadi:


```go
package main


import "fmt"


func main() {


var s []string
var n, i int

fmt.Print("Enter number of elements: ")


fmt.Scan(&n)

s = make([]string, n) // n ta matn qiymatli elementlarni saqlash uchun slice yaratish


fmt.Print("Enter elements: ")


for i = 0; i < n; i++ {
fmt.Scan(&s[i])
}

fmt.Println("Entered elements are:")


for i = 0; i < n; i++ {
fmt.Println(s[i])
}
}
```
Bu misolda, foydalanuvchi matn qiymatli elementlar sonini kiritadi. `make` yordamida, `n` ta matn qiymatli elementlarni saqlash uchun slice yaratiladi. `for` tsikli yordamida, foydalanuvchi tomonidan kiritilgan elementlar slice yordamida hafizaga yoziladi. `fmt.Println` yordamida, hafizaga yozilgan matn qiymati konsolga chiqariladi.
26. Selection sort (tanlangan saralash) algoritmi, bir massiv yoki boshqa bir ro'yxatni saralash uchun ishlatiladigan oddiy algoritm hisoblanadi. Bu algoritm, massivning eng kichik elementini topadi va uni birinchi element bilan almashtiradi. So'ngra, massivning keyingi eng kichik elementini topadi va uni ikkinchi element bilan almashtiradi. Bu jarayon massiv saralanib borilguncha davom ettiriladi.

Selection sort algoritmi quyidagi qadamlardan iboratdir:


1. Massivning boshlang'ich holatini olib, eng kichik elementni toping.


2. Eng kichik elementni massivning birinchi elementi bilan almashtiring.
3. Massivning qolgan qismini olib, eng kichik elementni toping.
4. Eng kichik elementni massivning ikkinchi elementi bilan almashtiring.
5. Bu jarayon massiv saralanib borilguncha davom ettiriladi.

Quyidagi misol, Selection sort algoritmi yordamida massivni saralashni ko'rsatadi:


```go
package main


import "fmt"


func selectionSort(arr []int) []int {


n := len(arr)

for i := 0; i < n-1; i++ {


minIndex := i
for j := i + 1; j < n; j++ {
if arr[j] < arr[minIndex] {
minIndex = j
}
}
arr[i], arr[minIndex] = arr[minIndex], arr[i]
}

return arr


}

func main() {


arr := []int{64, 25, 12, 22, 11}
fmt.Println("Unsorted array:", arr)

sortedArr := selectionSort(arr)


fmt.Println("Sorted array:", sortedArr)
}
```
Bu misol, Selection sort algoritmini Go dasturlash tili yordamida ishlatadi. `selectionSort` funksiyasi, bir integer massivini qabul qilib, massivni Selection sort algoritmi yordamida saralaydi va saralangan massivni qaytaradi. `main` funksiyasi, integer massivini yaratadi va uning eng kichik elementlari bilan saralangan holatda chiqaradi.
27. Bubble sort (balandliklar saralash) algoritmi, bir massiv yoki boshqa bir ro'yxatni saralash uchun ishlatiladigan oddiy algoritm hisoblanadi. Bu algoritm, massivning barcha elementlarini tekshiradi va ularni mos holatga keltirib boradi. Bu jarayon massiv saralanib borilguncha davom ettiriladi.

Bubble sort algoritmi quyidagi qadamlardan iboratdir:


1. Massivning boshlang'ich holatini olib, massivning birinchi elementi bilan keyingi elementni solishtiring.


2. Agar keyingi element birinchi elementdan kichik bo'lsa, ularni almashtiring.
3. Massivni oxirgi elementiga kelib chiqing. Agar bir qadamda elementlar almashtirilmasa, massiv saralandi deb hisoblangingiz mumkin.
4. Bu jarayon massiv saralanib borilguncha davom ettiriladi.

Quyidagi misol, Bubble sort algoritmi yordamida massivni saralashni ko'rsatadi:


```go
package main


import "fmt"


func bubbleSort(arr []int) []int {


n := len(arr)

for i := 0; i < n-1; i++ {


for j := 0; j < n-i-1; j++ {
if arr[j] > arr[j+1] {
arr[j], arr[j+1] = arr[j+1], arr[j]
}
}
}

return arr


}

func main() {


arr := []int{64, 25, 12, 22, 11}
fmt.Println("Unsorted array:", arr)

sortedArr := bubbleSort(arr)


fmt.Println("Sorted array:", sortedArr)
}
```
Bu misol, Bubble sort algoritmini Go dasturlash tili yordamida ishlatadi. `bubbleSort` funksiyasi, bir integer massivini qabul qilib, massivni Bubble sort algoritmi yordamida saralaydi va saralangan massivni qaytaradi. `main` funksiyasi, integer massivini yaratadi va uning birinchi elementi bilan saralangan holatda chiqaradi.
28. Shaker sort, Cocktail sort yoki Shake sort deb ataladigan tartiblash algoritmidir. Bu algoritm, Bubble sort bilan o`xshash ish rejimiga ega, ammo Bubble sort dan farqli ravishda, elementlarni ikki tomonlama ham tartiblaydi.

Algoritm nomi, kokteyl qarishmasi paydo bo'lishi bilan kelishilgan harakatdan ilhomlanilgan. Algoritm, elementlarni ikki tomonlama ham o'zaro almashtirib tartiblaydi.


C++ dasturlash tilida Shaker sort algoritmi quyidagi shaklda yozilishi mumkin:


```
void shaker_sort(int arr[], int n) {


bool swapped = true;
int start = 0;
int end = n - 1;

while (swapped) {


swapped = false;

// ileri tarafdan tartiblash


for (int i = start; i < end; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr[i], arr[i + 1]);
swapped = true;
}
}

if (!swapped)


break;

swapped = false;


end--;

// orqaga tarafdan tartiblash
for (int i = end - 1; i >= start; i--) {
if (arr[i] > arr[i + 1]) {
swap(arr[i], arr[i + 1]);
swapped = true;
}
}

start++;
}


}
```

Bu algoritm, massiv va massivning o`lchami deb ikki parametrga ega. Algoritm, o`zgaruvchilar yordamida massiv boshidan va oxiridan ishorat qilinadi. Keyin, while tsikli ichida, massivdagi elementlar tartiblanganda, ileri va orqaga tomonlardan tartiblash amaliyati o`tkaziladi. Ileri tarafdan tartiblash amaliyati massiv boshidan oxiriga yo'l oladi, orqaga tarafdan tartiblash amaliyati esa massiv oxiridan boshiga yo'l oladi.


Masalan, quyidagi kod Shaker sort algoritmini ishlatib, massiv elementlarini tartiblaydi:


```
int main() {


int arr[] = { 5, 3, 8, 6, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);

shaker_sort(arr, n);


for (int i = 0; i < n; i++) {


cout << arr[i] << " ";
}

return 0;


}
```
Ushbu kod { 5, 3, 8, 6, 4, 2 } kabi bir massivni tartiblaydi. Tartiblangan massiv quyidagi ko'rinishda bo'ladi: { 2, 3, 4, 5, 6, 8 }.
29. Insertion sort algoritmi, elementlarni tartiblangan ro`yxatga joylashtirib, yangi elementlarni ro`yxatga qo'shish va ro`yxatni o'sonlikda tartiblash asosida ishlaydigan algoritm hisoblanadi.

Bu algoritmda, ro`yxatning birinchi elementidan boshlab, ro`yxatni o'sonlikda tartiblash natijasida joylashtirilgan elementlarni o'ziga mos joyga qo'shadi. Ro`yxatdagi bir elementni to'g'ri joyiga joylashtirish uchun, keyingi elementlar bilan solishtiriladi va birinchi to'g'ri joyga joylashtiriladi. Bu jarayon ro`yxat oxirigacha takrorlanadi.


C++ dasturlash tilida Insertion sort algoritmi quyidagi shaklda yozilishi mumkin:


```
void insertion_sort(int arr[], int n) {


int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i];
j = i - 1;

while (j >= 0 && arr[j] > key) {


arr[j + 1] = arr[j];
j = j - 1;
}

arr[j + 1] = key;


}
}
```

Bu algoritm massiv va massivning o`lchami deb ikki parametrga ega. Algoritm massivdagi har bir elementni tartiblash uchun bir tsikl yordamida ishlaydi. Tsikldagi har bir amal, bir elementni to'g'ri joyga joylashtirish uchun amalga oshiriladi.


Masalan, quyidagi kod Insertion sort algoritmini ishlatib, massiv elementlarini tartiblaydi:


```
int main() {


int arr[] = { 5, 3, 8, 6, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);

insertion_sort(arr, n);


for (int i = 0; i < n; i++) {


cout << arr[i] << " ";
}

return 0;


}
```
Ushbu kod { 5, 3, 8, 6, 4, 2 } kabi bir massivni tartiblaydi. Tartiblangan massiv quyidagi ko'rinishda bo'ladi: { 2, 3, 4, 5, 6, 8 }.
30. Quick sort, bir dizi elementlarini saralash uchun keng tarqalgan algoritm hisoblanadi. Bu algoritm, pivot elementini tanlab, bu elementdan kichik elementlarni pivot elementning chapidan, katta elementlarni esa o'ngidan joylashtiradi. Shu jarayonni rekursiv ravishda takrorlaydi va bularning hammasi saralanadi.

Quick sort algoritmi, dizi elementlarini saralash uchun qayta qayta ishlatiladigan algoritm hisoblanadi. Dizi elementlari, pivot elementi etrafida bo'linib, sub-massivlarga ajratiladi va ushbu sub-massivlar saralash algoritmi bilan saralanadi. Ushbu jarayon, sub-massivlar o'lchami 1 ga teng yoki undan kichik bo'lgan paytda tugatiladi.


C++ dasturlash tilida Quick sort algoritmi quyidagi shaklda yozilishi mumkin:


```
void quick_sort(int arr[], int low, int high) {


if (low < high) {
int pi = partition(arr, low, high);

quick_sort(arr, low, pi - 1);


quick_sort(arr, pi + 1, high);
}
}

int partition(int arr[], int low, int high) {


int pivot = arr[high];
int i = (low - 1);

for (int j = low; j <= high - 1; j++) {


if (arr[j] < pivot) {
i++;
swap(arr[i], arr[j]);
}
}

swap(arr[i + 1], arr[high]);


return (i + 1);
}
```

Bu algoritmda massiv, massivning boshlang'ich va oxirgi indekslari deb uchta parametr qabul qilinadi. Algoritm, rekursiv bir qo'llanma ishlatib massiv elementlarini saralaydi. Tsikllar, pivot elementi etrafidagi sub-massivlarga ajratilishni amalga oshiradi.


Masalan, quyidagi kod Quick sort algoritmini ishlatib, massiv elementlarini tartiblaydi:


```
int main() {


int arr[] = { 5, 3, 8, 6, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);

quick_sort(arr, 0, n - 1);


for (int i = 0; i < n; i++) {


cout << arr[i] << " ";
}

return 0;


}
```

Ushbu kod { 5, 3, 8, 6, 4, 2 } kabi bir massivni tartiblaydi. Tartiblangan massiv quyidagi ko'rinishda bo'ladi: { 2, 3, 4, 5, 6, 8 }.


31. Merge sort, bir massivni saralash uchun ishlatiladigan algoritm hisoblanadi. Bu algoritm, massivni har bir marta ikki qisimga ajratib, har bir qismini alohida saralaydi va keyin ikki saralgan qismini bir-biriga qo'shib yana saralash jarayoniga o'tkaziladi. Ushbu jarayon, ikki qisim qolmasa to'g'ri keladi.

C++ dasturlash tilida Merge sort algoritmi quyidagi shaklda yozilishi mumkin:


```
void merge_sort(int arr[], int l, int r) {


if (l < r) {
int m = l + (r - l) / 2;

merge_sort(arr, l, m);


merge_sort(arr, m + 1, r);

merge(arr, l, m, r);


}
}

void merge(int arr[], int l, int m, int r) {


int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;

int L[n1], R[n2];


for (i = 0; i < n1; i++) {


L[i] = arr[l + i];
}

for (j = 0; j < n2; j++) {


R[j] = arr[m + 1 + j];
}

i = 0;
j = 0;


k = l;

while (i < n1 && j < n2) {


if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}

while (i < n1) {


arr[k] = L[i];
i++;
k++;
}

while (j < n2) {


arr[k] = R[j];
j++;
k++;
}
}
```

Bu algoritm massiv, massivning boshlang'ich va oxirgi indekslari deb uchta parametr qabul qilinadi. Algoritmning birinchi qadamida, massivning o'rtasini topish lozim. Keyin, chap va o'ng tomonlardagi sub-massivlarni saralash algoritmi bilan alohida saralaydi. Oxirgi qadam, saralgan sub-massivlarni bir-biriga qo'shishdir.


Masalan, quyidagi kod Merge sort algoritmini ishlatib, massiv elementlarini tartiblaydi:


```
int main() {


int arr[] = { 5, 3, 8, 6, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);

merge_sort(arr, 0, n - 1);


for (int i = 0; i < n; i++) {


cout << arr[i] << " ";
}

return 0;


}
```
Ushbu kod { 5, 3, 8, 6, 4, 2 } kabi bir massivni tartiblaydi. Tartiblangan massiv quyidagi ko'rinishda bo'ladi: { 2, 3, 4, 5, 6, 8 }.
32. Comb sort saralash algoritmi, bir massivni saralash uchun ishlatiladigan algoritm hisoblanadi. Bu algoritm massiv elementlari orasidagi masofani ortish uchun gap ni o'z ichiga oladi va massivni saralash jarayonini o'tkazadi. Gap uzayuvchan bo'lgani uchun, algoritmning saralanishi bir necha marta takrorlanadi.

C++ dasturlash tilida Comb sort algoritmi quyidagi shaklda yozilishi mumkin:


```
void comb_sort(int arr[], int n) {


int gap = n;
float shrink = 1.3;
bool sorted = false;

while (!sorted) {


gap = floor(gap / shrink);
if (gap > 1) {
sorted = false;
}
else {
gap = 1;
sorted = true;
}

int i = 0;


int j = gap;

while (j < n) {


if (arr[i] > arr[j]) {
swap(arr[i], arr[j]);
sorted = false;
}

i++;
j++;


}
}
}
```

Bu algoritm massiv va massiv uzunligi deb ikkita parametrga ega. Algoritm gap qiymatini n qiymatini olib, keyin gap qiymatini kichraytirish uchun kichiklash faktoriga ega bo'ladi. Gap qiymati 1 bo'lganda saralash jarayoni tugallangan deb hisoblanadi.


Masalan, quyidagi kod Comb sort algoritmini ishlatib, massiv elementlarini tartiblaydi:


```
int main() {


int arr[] = { 5, 3, 8, 6, 4, 2 };
int n = sizeof(arr) / sizeof(arr[0]);

comb_sort(arr, n);


for (int i = 0; i < n; i++) {


cout << arr[i] << " ";
}

return 0;


}
```

Ushbu kod { 5, 3, 8, 6, 4, 2 } kabi bir massivni tartiblaydi. Tartiblangan massiv quyidagi ko'rinishda bo'ladi: { 2, 3, 4, 5, 6, 8 }.


33. Tree sort saralash algoritmi, bir necha elementlardan iborat bo'lgan to'plamni saralash uchun ishlatiladigan bir algoritmadir. Bu algoritm, boshlang'ich to'plamni bir aga aylantiradi va shu agacha elementlarni qo'shadi. Keyinchalik, aga ustida o'tib, elementlarni bo'sh joyni bo'lmagan holda chiqaradi.

Algoritmda, har bir element aga yoki undan tashqari joylashgan undan kichik elementlari va undan katta elementlari o'z ichiga olgan ikkita bo'limdan iborat bo'ladi. Aga yagona boshlang'ich elementni o'z ichiga oladi. Keyingi elementlar esa, ularni qo'shish orqali aga joylashadi. Aga ustida o'tirish jarayonida, qo'shilgan har bir elementni o'z joyiga tushirish kerak.


Misol uchun, quyidagi sonlar to'plamini saralash uchun Tree sort algoritmini ko'ramiz:


```
To'plam: 8, 3, 1, 5, 12, 10, 6, 9

Aga:

8
/ \
3 12
/ / \
1 10 14
/ \
6 9

Saralangan to'plam:


1, 3, 5, 6, 8, 9, 10, 12


```

Bu misolda, boshlang'ich to'plamimizda 8 elementi bor. Aga yaratiladi va 8 elementi uchun boshlang'ich element sifatida qo'yiladi. Keyingi element 3 bo'ladi, shu element aga ustiga qo'shiladi. Keyinchalik, 1, 5, 12, 10, 6, va 9 elementlari qo'shiladi. Aga ustida o'tib, hamma elementlar saralandi va saralgan to'plam quyidagicha bo'ldi: 1, 3, 5, 6, 8, 9, 10, 12.


34. Gnome sort saralash algoritmi, bir necha elementlardan iborat bo'lgan to'plamni saralash uchun ishlatiladigan bir algoritmadir. Bu algoritm, bir elementni oldingi element bilan solishtiradi. Agar oldingi elementdan katta bo'lsa, ularni o'zgartiradi va bir avvalgi element bilan qaytadan solishtiradi. Bu jarayon to'plamning boshidan boshlab oxirigacha davom etadi.

Misol uchun, quyidagi sonlar to'plamini saralash uchun Gnome sort algoritmini ko'ramiz:


```
To'plam: 8, 3, 1, 5, 12, 10, 6, 9

Saralangan to'plam:


1, 3, 5, 6, 8, 9, 10, 12


```
Bu misolda, boshlang'ich to'plamimizda 8 element mavjud. Algoritmda, birinchi element bilan ikkinchi elementni solishtirish boshlanadi. 3 elementi 8 dan katta bo'lsa, ularni o'zgartirib, algoritma boshidan boshlab qayta boshlanadi. 1 elementi esa, 3 dan kichik bo'lsa, ularni o'ziga o'tkazadi va 5 elementiga o'tkaziladi. 5 dan katta bo'lsa, ularni o'zgartirib, to'plamni boshidan boshlab qayta saralash boshlanadi. Bunda, 3 elementi 5 dan katta bo'lsa, ularni o'zgartirib, qayta saralash jarayoniga qaytadi. Shunday davom etib, hamma elementlar saralandi va saralgan to'plam quyidagicha bo'ldi: 1, 3, 5, 6, 8, 9, 10, 12.
35. Heap sort saralash algoritmi, bir necha elementlardan iborat bo'lgan to'plamni saralash uchun ishlatiladigan bir algoritmadir. Bu algoritm, elementlarni bo'sh joyi bo'lmagan to'plamda joylashgan bo'lgan bir "max heap" yaratadi. Keyinchalik, "max heap" dan eng katta elementni o'zgartiradi, o'zgartirgan elementni to'plamning oxiriga joylashtiradi va undan yana "max heap" yaratish jarayonini qayta boshlashadi. Bunda, to'plam saralangan bo'ladi.

"Max heap" yaratish jarayoni quyidagicha bo'ladi: Boshlang'ich to'plamni o'ziga o'tkazib, "max heap" yaratiladi. Keyinchalik, "max heap" dan eng katta elementni o'zgartiriladi va undan foydalanib, to'plamning oxiriga joylashtiriladi. "Max heap" dan o'chirilgan eng katta elementga o'zgartirilish jarayoni qayta boshlanadi. Bunda, to'plam saralandi.


Misol uchun, quyidagi sonlar to'plamini saralash uchun Heap sort algoritmini ko'ramiz:


```
To'plam: 8, 3, 1, 5, 12, 10, 6, 9

Saralangan to'plam:


1, 3, 5, 6, 8, 9, 10, 12


```

Bu misolda, boshlang'ich to'plamimizda 8 element mavjud. Algoritmda, "max heap" yaratiladi. Keyinchalik, "max heap" dan eng katta element olib, to'plamning oxiriga joylashtiriladi. Bunda, to'plam quyidagicha bo'lib qoladi: 9, 3, 1, 5, 12, 10, 6, 8. "Max heap" dan o'chirilgan eng katta element 8 ga o'zgartiriladi. Keyinchalik, to'plamning oxiriga joylashtiriladi va to'plam quyidagicha bo'lib qoladi: 9, 3, 1, 5, 12, 10, 6. "Max heap" dan o'chirilgan eng katta element 6 ga o'zgartiriladi. Keyinchalik, to'plamning oxiriga joylashtiriladi va to'plam quyidagicha bo'lib qoladi: 9, 3, 1, 5, 12, 10. Shunday davom etib, hamma elementlar saralandi va saralgan to'plam quyidagicha bo'ldi: 1, 3, 5, 6, 8, 9, 10, 12.


36. Shell sort saralash algoritmi, bir necha elementlardan iborat bo'lgan to'plamni saralash uchun ishlatiladigan bir algoritmadir. Bu algoritm, elementlarni bo'sh joyi bo'lmagan to'plamda joylashgan bo'lgan bir "gap" yaratadi. Gap, o'zgaruvchilarni bo'lgan masofani belgilaydi. Keyinchalik, gap ni kichikaytiradi va elementlarni "insertion sort" yordamida saralaydi. Bunda, to'plam saralangan bo'ladi.

"Gap" yaratish jarayoni quyidagicha bo'ladi: Boshlang'ich to'plamni "gap" ni o'ziga o'tkazib, "gap" yaratiladi. Keyinchalik, "gap" ni kichikaytirib, to'plamni "insertion sort" yordamida saralash boshlanadi. Bunda, to'plam saralandi.


Misol uchun, quyidagi sonlar to'plamini saralash uchun Shell sort algoritmini ko'ramiz:


```
To'plam: 8, 3, 1, 5, 12, 10, 6, 9

Saralangan to'plam:


1, 3, 5, 6, 8, 9, 10, 12


```

Bu misolda, boshlang'ich to'plamimizda 8 element mavjud. Algoritmda, "gap" yaratiladi. Keyinchalik, "gap" ni kichikaytirib, to'plamni "insertion sort" yordamida saralash boshlanadi. Bu misolda, boshlan'gich "gap" 4 bo'lsa, keyinchalik, 4 element qatorlariga bo'linadi va ularni "insertion sort" bilan saralash boshlanadi. 1-4, 5-8, va 9-12 elementlari "insertion sort" yordamida saralandi. Quyidagicha bo'lib qoladi: 1, 3, 5, 6, 8, 9, 10, 12. Bunda, to'plam saralandi.


37. Visual Studio, Microsoft tomonidan ishlab chiqilgan integratsion muhiti (IDE) dasturi hisoblanadi. Bu dastur, C++, C#, Visual Basic, F# va boshqa bir qancha tilda yozilgan dasturlarni tuzish uchun mo'ljallangan. Bu dastur, Windows operatsion tizimida ishlaydi va bir qancha imkoniyatlar bilan ta'minlanadi.

Visual Studio dasturi quyidagi imkoniyatlar bilan ta'minlanadi:


1. Kod yozish va tahrir qilish: Visual Studio, dasturlash uchun keng tarqalgan muharrirga ega. Bu muharrir, sintaksis yordamida ranglar ko'rsatadi, xatoliklarni aniqlab beradi va kodni qulay ko'rinishga o'tkazadi.


2. Debug qilish: Visual Studio, kodni tekshirish va xatoliklarini aniqlash uchun integratsiyalangan debug qo'llanma yordamida ishlaydi. Bu qo'llanma, kodni qadam po qadam bajarishga imkon beradi va xatoliklarni aniqlashga yordam beradi.


3. Proyektlar yaratish: Visual Studio, bir nechta dasturlash tillarida dasturlarni tuzish uchun proyektlar yaratish imkoniyatiga ega. Bu proyektlar, dasturlar vaqtinchalik fayllarni ko'chirish va ularda boshqarishga imkon beradi.


4. Git integratsiyasi: Visual Studio, Git-ni boshqa dasturlardan farqli ravishda integratsiyalashni taqdim etadi. Bu, kompaniya yoki jamoatchilikda kodni birlashtirishga yordam beradi.


5. Test qilish: Visual Studio, dasturlarni tekshirish uchun boshqa bir qancha imkoniyatlarga ega. Bu imkoniyatlar orasida, unit-testlar, integration-testlar, code coverage va boshqa imkoniyatlar kiritilgan.


6. Konsol va GUI dasturlar: Visual Studio, konsol va GUI dasturlarini yaratishga imkon beradi. Bu, Windows Forms, WPF va boshqa tuzilishlarni o'z ichiga oladi.


7. Cloud integratsiyasi: Visual Studio, Azure va boshqa cloud xizmatlariga integratsiyalashni taqdim etadi. Bu, kodni birlashtirish, test va deploy qilishni osonlashtiradi.


8. Extensions: Visual Studio, qo'shimcha funksiyalarni o'rnatishga imkon beradi. Bu funksiyalar, boshqa kompaniyalar yoki jamoatchiliklar tomonidan yaratilgan va Visual Studio-ni kengaytirishga yordam beradi.


9. Code Snippets: Visual Studio, kod qismlarini tez yozish uchun "code snippets" yordamida yozishga imkon beradi.


Bu imkoniyatlar faqat bir necha misoldan iborat emas, ammo bu dasturning bir nechta imkoniyatlarini ta'minlashga yordam beradi.


38. Visual Studio, dasturlashda qo'llaniladigan bir qancha komponentalarni yaratish uchun mo'ljallangan. Bu komponentalar, tashqi va dasturiy interfeyslar, xizmatlar, boshqa API va qo'shimcha funksiyalarni qo'llash uchun mo'ljallangan.

Quyidagi komponentalar Visual Studio-da odatda ishlatiladigan:


1. Windows Forms: Bu komponenta, Windows ilovalarining klassik interfeysini yaratish uchun qo'llaniladi. Bu, Windows Forms Designer orqali yaratiladi va ikki qismga bo'linadi - "designer" va "code-behind".


2. WPF (Windows Presentation Foundation): Bu komponenta, Windows ilovalarining modern interfeysini yaratish uchun qo'llaniladi. Bu, XAML (Extensible Application Markup Language) orqali yaratiladi va har qanday dasturlash tilini qo'llash imkoniyatiga ega.


3. ASP.NET: Bu komponenta, web ilovalarini yaratish uchun qo'llaniladi. Bu, Visual Studio-ni o'z ichiga olgan har qanday qo'llanuvchi tomonidan ko'p xil web ilovalarini yaratish uchun mo'ljallangan.


4. Universal Windows Platform (UWP): Bu komponenta, Windows 10 uchun ilovalar yaratish uchun qo'llaniladi. Bu, XAML orqali yaratiladi va Windows 10-da qo'llaniladigan barcha qurilma turlari uchun ilovani yaratishga imkon beradi.


5. Xamarin: Bu komponenta, mobil ilovalar yaratish uchun qo'llaniladi. Bu, .NET platformasida yaratilgan va iOS, Android va Windows Phone uchun ilovalar yaratishga imkon beradi.


6. SQL Server Data Tools: Bu komponenta, SQL Server ma'lumotlar bazalari (DB) yaratish uchun qo'llaniladi. Bu, Visual Studio-ni o'z ichiga oladi va ma'lumotlar bazasini yarating, jadvallarni yaratish va ularda malumotlar kiritishga imkon beradi.


7. Entity Framework: Bu komponenta, ma'lumotlar bazalariga bog'liq ishlarni yaxshiroq bajarish uchun qo'llaniladi. Bu, ma'lumotlar bazasini ob'ektga aylantiradi va shuningdek, LINQ yordamida malumotlar bazasiga so'rovlar yuborishga imkon beradi.


8. Azure SDK: Bu komponenta, Azure cloud xizmatlariga bog'liq ishlarni yaxshiroq bajarish uchun qo'llaniladi. Bu, Azure xizmatlariga ulang va ularni yaratish, boshqarish, joylashtirish va boshqa ishlarni bajarishga imkon beradi.


Bu komponentalar faqat bir necha misoldan iborat emas, ammo ularning har biri dasturlashdagi bir necha muhim aspektlarga asosiy ta'sir ko'rsatadi.


39. Visual Studio, grafik interfeyslarni yaratish va ularga o'zgartirish uchun bir necha imkoniyatlarga ega. Bu imkoniyatlar quyidagicha:

1. Windows Forms Designer: Bu muharrir, Windows Forms komponentalarini o'zgartirish uchun mo'ljallangan. Bu, interfeysdagi elementlarni, odatda, drag-and-drop usulida joylashtirish yordamida o'zgartirish imkoniyatiga ega.


2. XAML Designer: Bu muharrir, WPF va UWP ilovalarining XAML fayllarini tahrir qilish uchun mo'ljallangan. Bu, interfeysdagi elementlarni, drag-and-drop usulida joylashtirish yordamida o'zgartirish imkoniyatiga ega.


3. Graphics Debugger: Bu debugger, grafik ilovalarni tekshirish uchun mo'ljallangan. Bu, ilovadagi grafik elementlarini o'zgartirish yoki ularga to'g'ridan-to'g'ri qarash yordamida xatoliklarni aniqlashga imkon beradi.


4. IntelliTrace: Bu debugger, ilovadagi xatoliklarni aniqlash uchun mo'ljallangan. Bu, ilovadagi xatoliklarni aniqlash uchun ilovani qayta boshlash shart emas, balki xatolikni aniqlash uchun ilovadagi har bir ishni kuzatishga imkon beradi.


5. Code Analysis: Bu, kodni tekshirish uchun mo'ljallangan. Bu, kodni sintaksisini va xususiyatlarini tekshirish uchun qo'llaniladi. Bu, kodni xatoliklardan tekshirishga yordam beradi va kodni yaxshi kengaytirishga imkon beradi.


6. DirectX Graphics Diagnostics: Bu debugger, DirectX ilovalarini tekshirish uchun mo'ljallangan. Bu, ilovadagi grafiklarni tekshirish va ularda xatoliklarni aniqlashga imkon beradi.


Ushbu imkoniyatlar, Visual Studio-ni grafik interfeyslarni yaratish va ularga o'zgartirish uchun yaxshi platforma qiladi. Bu, dasturchilarga, ilovalarni yaratish va ularda xatoliklarni aniqlash uchun yordam beradi.


40. OLE (Object Linking and Embedding) va MFC (Microsoft Foundation Classes) Microsoft tomonidan ishlab chiqilgan dasturlash asboblaridir. Bu asboblar, Windows ilovalarini yaratishda qo'llaniladigan uslublar, yo'nalishlar va kutubxonalardir.

OLE tushunchasi:


OLE, ilovadagi ob'ektlarni yaratish, ularga o'zgartirish va ularga murojaat qilish uchun mo'ljallangan dasturlash uslubi hisoblanadi. Bu, ob'ektlarni boshqa ilovalarga joylashtirish va ularda ko'rsatish uchun ham qo'llaniladi. OLE, "embedding" va "linking" qilish imkoniyatlarini taqdim etadi. "Embedding", bir ilova ichidagi ob'ektni boshqa ilovaga joylashtirishni anglatadi, "linking" esa, ob'ektni boshqa ilova ichidagi ma'lumotlar bilan bog'lashni anglatadi. OLE, OLE Automation va ActiveX Controlni ham o'z ichiga oladi.


MFC tushunchasi:


MFC, Windows ilovalarini yaratishda qo'llaniladigan kutubxonalar to'plamidir. Bu, Windows API-ni osonlashtrish va ob'ektoriyentatsiyalashga qaratilgan. MFC, C++ ilovalarini yaratish va ularda Windows komponentalarini qo'llash uchun mo'ljallangan. Bu, dialoglar, menu, toolbars, status bars va boshqa ko'plab interfeys elementlarini yaratish imkonini beradi.


MFC, bir qancha imkoniyatlar bilan ta'minlanadi:


1. Windows interfeysining yaratilishini osonlashtirish: MFC, dialoglar, menu, toolbars, status bars va boshqa ko'plab interfeys elementlarini yaratish imkonini beradi.


2. Komponentlar yaratish: MFC, Windows interfeysining yaratilishining yanada osonlashtirilishiga yordam beradi. Bu, yana boshqa komponentlarni yaratish, masalan, bilan yaqinlashish, ma'lumotlar bazalariga murojaat qilish va boshqalar.


3. Ob'ektoriyentatsiya: MFC, ob'ektlar yaratish va ularga murojaat qilish yordamida ob'ektoriyentatsiyani osonlashtiradi. Bu, kodni tozalash, qayta ishlatish va yaxshi tashqi interfeyslar yaratishga imkon beradi.


4. Kutubxona yaratish: MFC, kutubxonalar yaratish uchun mo'ljallangan. Bu, bir necha ilovalarda qaytariladigan bir necha kod qismlarini qayta ishlatishga imkon beradi.


5. Windows API-ni osonlashtirish: MFC, Windows API-ni osonlashtirish uchun mo'ljallangan. Bu, Windows API-ni to'liq qo'llashdan qo'rqishdan chiqishga yordam beradi.


OLE va MFC, Windows ilovalarini yaratishda qo'llaniladigan mo'ljallar hisoblanadi. Bu mo'ljallar, ilovadagi ob'ektlarni yaratish, ularga murojaat qilish, Windows interfeysini osonlashtirish va yana ko'plab imkoniyatlarni taqdim etadi.


41. Foydalanuvchi interfeysi (FI) loyihalashda quyidagi narsalarga e'tibor qaratish lozim:

1. Foydalanuvchi tomonidan tushiriladigan talablar: FI loyihalashida, foydalanuvchi talablari va ularni qondirishga e'tibor berish lozim. Talablar foydalanuvchilarning interfeysni qanday ishlatishini, ko'rishini va tushirishini ta'minlashga yordam beradi.


2. Kengaytirish imkoniyatlari: FI loyihalashida, foydalanuvchilarga interfeysni o'zgartirishga imkon berish lozim. Bu, ekran o'lchamini o'zgartirish, interfeys elementlarini ko'rsatishni yoki yashirishni ta'minlash va boshqa imkoniyatlarni ko'rsatishni o'z ichiga oladi.


3. Qulaylik: FI loyihalashida, foydalanuvchilarga interfeysni qulaylik bilan ta'minlash lozim. Bu, interfeysning oson tushirilishi, juda ko'p ishlatishga imkon berish va boshqa qulayliklar.


4. Konseptual tasavvurlar: FI loyihalashida, interfeysning tasavvurini va konseptual tushunchalarini yaxshiroq aniqlash lozim. Bu, interfeysning tuzilishi va ularni tushirishga qarshi foydalanuvchining tushunishini yaxshilashga yordam beradi.


5. Klassifikatsiya: FI loyihalashida, interfeys elementlarini to'plamlarga, guruhlarga, yoki kategoriyalarga bo'lishga qaror qabul qilish lozim. Bu, interfeysning tuzilishi, tushirishi va foydalanuvchilar tomonidan tushirilishi bilan bog'liq masalalarni hal qilishga yordam beradi.


6. Test qilish: FI loyihalashida, interfeysni test qilishga e'tibor berish lozim. Bu, interfeysning talablarga javob bermoqda yaxshi ishlashi va yana boshqa xatoliklar yo'q qilishga yordam beradi.


Misollar:


1. Mobil ilova interfeysi: Mobil ilovalar, ochiq interfeys tizimiga ega bo'lishi kerak. Interfeys, kichik ekranda ham oson tushirilishi, qulay va intuitiv bo'lishi kerak. Masalan, mobil ilova interfeysi, ekran o'lchamiga mos keladigan menular, tugmalar va elementlar qo'llanadi.


2. Boshqaruv paneli interfeysi: Boshqaruv paneli, bitta joyda ko'p ishni bajarishga yordam beradi. Boshqaruv panelining interfeysi, ishni bajarishning qulay va oson yechilishiga imkon berishi kerak. Masalan, boshqaruv paneli interfeysi, ishchi yordamchining ishini bajarishini osonlashtirish uchun ish elementlarini yashirish yoki ko'rsatish imkoniyatiga ega bo'ladi.




3. Veb-sayt interfeysi: Veb-saytlar, ko'pincha qulay va oson tushirilishi kerak. Interfeys, saytni ishlatuvchilar uchun oson tarzda navigatsiya qilishga yordam berishi kerak. Masalan, veb-sayt interfeysi, yorliqlarni o'z ichiga oladi va saytni ishlatuvchilar uchun qulay navigatsiya tizimini ta'minlaydi.

Download 42,78 Kb.
1   2




Download 42,78 Kb.

Bosh sahifa
Aloqalar

    Bosh sahifa



Dasturlash II yakuniy nazorat javoblari. Savollar

Download 42,78 Kb.