|
Dasturlash II yakuniy nazorat javoblari. Savollar
|
| bet | 2/2 | | Sana | 30.01.2024 | | Hajmi | 42,78 Kb. | | #148477 |
Bog'liq Dasturlash ii yakuniy nazorat javoblariJAVOBLAR
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
|
| |
