Dasturlash II 7-hafta mavzu: shablonlar, vektorlar va steklar

const int KARTALAR_SONI = 52;
vector <int> dasta(KARTALAR_SONI);
//Kartalarni yuklash
for (int i = 0; i < KARTALAR_SONI; i++)
dasta[i] = i;
dasta[0] dan dasta[12] gacha tapponlar, dasta[13] dan dasta[25] gacha g`ishtlar, dasta[26] dan dasta[38] gacha tapponlar va dasta[39] dan dasta[51] gacha qarg`alar. Ushbu muammo 7.4-kodli ro`yxatda yechilgan.
7.4-kodli ro`yxat. vektorliKartaDastasi.cpp
1 #include
2 #include
3 #include
4 #include
5 using namespace std;
6
7 const int KARTALAR_SONI = 52;
8 string moslik[] = {"Qarg`a", "Tappon", "G`isht", "Chillak"};
9 string raqamlar[] = {"Tuz","2","3","4","5","6","7","8","9",
10 "10","Valet","Dama","Qirol"};
11
12 int main()
13 {
14 vector<int> dasta(KARTALAR_SONI);
15
16 // Boshlang`ich kartalar
17 for (int i = 0; i < KARTALAR_SONI; i++)
18 dasta[i] = i;
19
20 // Kartalarni aralashtirish
21 srand(time(0));
22 for(int i = 0; i < KARTALAR_SONI; i++)
23 {
24 // Tasodifiy indeksni generatsiyalash
25 int index = rand() % KARTALAR_SONI;
26 int temp = dasta[i];
27 dasta[i] = dasta[index];
28 dasta[index] = temp;
29 }
30
31 // Birinchi to`rtta kartani ko`rsatish
32 for (int i = 0; i < 4; i++)
33 {
34 cout << i+1 << " raqamli karta nomi: " << moslik[dasta[i] / 13] <<
35 ", karta raqami: " << raqam[dasta[i] % 13] << endl;
36 }
37
38 return 0;
39 }
Natija:

4 raqamli karta nomi: Chillak Tuz raqamli karta nomi: G`isht 6 raqamli karta nomi: Tappon Valet raqamli karta nomi: Chillak

Dastur uning 2-qatorida vector sinfi chaqirilishi va 14-qatorda barcha kartalarni massivda yozishda vektordan foydalanilishini inobatga olmaganda, 7.3-kodli ro`yxat bilan deyarli bir xil. Shunisi qiziqki, massivdan va vektordan foydalanish sintaksisi bir xil, chunki massivning ham, vektorning ham ma’lum bir elementiga murojaat oraliqni ifodalovchi [] operatori orqali amalga oshiriladi.

Shuningdek, 8-10-qatorlardagi moslik va raqamlar massivlarini vektorga o`zgartirishimiz ham mumkin. Agar dasturda ko`p qatorlarni yozishimiz kerak bo`lsa, u holda bu elementlarni vektorga yozgan ma’qul. Kodlashtirishda massivlardan foydalanish soddaroq va yaxshiroq hisoblanadi.
O`tgan semestrda o`rganganimiz, funksiyaga ikki o`lchovli massivni yuborishga doir tuzilgan 13.1-dasturga qayta murojaat etamiz.
13.1-kodli ro`yxat. IkkiUlchovliMassivniYuborish.cpp //(o`tgan semestrdagi)
1 #include
2 using namespace std;
3
4 const int USTUN_HAJM = 4;
5
6 int sum (const int a[][USTUN_HAJM], int satrHajm)
7 {
8 int jami = 0;
9 for (int satr = 0; satr < satrHajm; satr++)
10 {
11 for (int ustun = 0; ustun < USTUN_HAJM; ustun++)
12 {
13 jami += a[satr][ustun];
14 }
15 }
16
17 return jami;
18 }
19
20 int main()
21 {
22 const int SATR_HAJM = 3;
23 int m[SATR_HAJM][USTUN_HAJM];
24 cout << SATR_HAJM << " ta satr va "
25 << USTUN_HAJM << " ta ustun kiriting: "<< endl;
26 for (int i = 0; i < SATR_HAJM; i++)
27 for (int j = 0; j < USTUN_HAJM; j++)
28 cin >> m[i][j];
29
30 cout << "\nBarcha elementlar yig`indisi: "
31 << sum(m, SATR_HAJM) << endl;
32
33 return 0;
34 }

Bu dastur ikki o`lchovli massiv yaratadi va uning elementlari yig`indisini hisoblab qaytaruvchi funksiyani chaqiradi.

Vektorlar vektorini ikki o`lchovli massiv sifatida qo`llashimiz mumkin. Quyidagi misol to`rtta satrga va uchta ustunga ega bo`lgan massivni taqdim etadi:
vectorint> > matrix(4); // to`rta satr
for (int i = 0; i < 4; i++)
matrix[i] = vector<int>(3);
matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3;
matrix[1][0] = 4; matrix[1][1] = 5; matrix[1][2] = 6;
matrix[2][0] = 7; matrix[2][1] = 8; matrix[2][2] = 9;
matrix[3][0] = 10; matrix[3][1] = 11; matrix[3][2] = 12;


Eslatma.
vectorint> > matrix(4); // to`rta satr
satrida ikkita > va > bo`sh joy bilan ajratilgan. Agar bo`sh joy qoldirilmasa, ba’zi eski C++ kompilyatorlari uni tanimasligi mumkin.

7.5-kodli ro`yxat 13.1-kodli ro`yxat. IkkiUlchovliMassivniYuborish.cpp ni vektorlarni ishlatgan holda qayta ko`rib chiqadi.

7.5-kodli ro`yxat. TwoDArrayUsingVector.cpp
1 #include
2 #include
3 using namespace std;
4
5 int sum(const vectorint>>& matrix)
6 {
7 int total = 0;
8 for (unsigned row = 0; row < matrix.size(); row++)
9 {
10 for (unsigned column = 0; column < matrix[row].size(); column++)
11 {
12 total += matrix[row][column];
13 }
14 }
15
16 return total;
17 }
18
19 int main()
20 {
21 vectorint>> matrix(4); // to`rta satr
22
23 for (unsigned i = 0; i < 4; i++)
24 matrix[i] = vector<int>(3); // Each row has three columns
25
26 matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3;
27 matrix[1][0] = 4; matrix[1][1] = 5; matrix[1][2] = 6;
28 matrix[2][0] = 7; matrix[2][1] = 8; matrix[2][2] = 9;
29 matrix[3][0] = 10; matrix[3][1] = 11; matrix[3][2] = 12;
30
31 cout << "Barcha elementlar yig`indisi: " <32
33 return 0;
34 }
Natija:

Barcha elementlar yig`indisi: 78

Bu kodda matrix o`zgaruvchisi vektor sifatida e’lon qilingan. matrix[i] vektorining har bir elementining o`zi alohida vektor. Shunday qilib, matrix[i][j] ikki o`lchovli massivda i-satr, j-ustunni ifodalaydi.

sum funksiyasi vektordagi barcha elementlar yig`indisini qaytaradi. Vektor o`lchami vector sinfidagi size() funksiyasidan olinishi mumkin. Shuning uchun ham, sum funksiyasi chaqirilganda muayyan vector hajmiga ega bo`lmaymiz. Ikki o`lchovli massivga mo`ljallangan funksiyaning o`zi quyidagicha ikkita parametrni talab qiladi:
int sum(const int a[][COLUMN_SIZE], int rowSize)
Ikki o`lchovli massivlarni ifodalashda vektorlardan foydalanish kodlashtirishni soddalashtiradi.


7.4. Amaliy qism: Ifodalarni baholash
Key Point. Ifodalarni hisoblashda stekdan foydalanish mumkin.
Steklar ko`plab amaliy dasturlar sohasiga ega. Ushbu qismda stekdan foydalanuvchi dastur beriladi. Biz arifmetik ifodani hisoblash uchun quyidagicha Google ga kiritishimiz mumkin:

7.2-rasm. Arifmetik ifodalarni Google orqali hisoblash mumkin.
Google ifodani qanday hisoblaydi? Bu qism operatorlar va qavslardan iborat ifodalar jamlanmasini hisoblovchi dastur ko`rib chiqiladi. Oddiylik uchun, operandlarni butun turli va operatorlarni to`rtta tur: +, –, *, va / lardan iborat deb tasavvur qilamiz.
Masalani yechish uchun operandlar va operatorlarni ketma-ket yozishga mo`ljallangan, operandStack va operatorStack deb nomlangan ikkita stekdan foydalanish mumkin. Operandlar va operatorlar ularga ishlov berilishidan avval stekka qo`shiladi. Operator bajarilgandan so`ng, u operatorStack stekdan olinadi va operandStack dagi ikkita operandlar uchun qo`llaniladi (ikki operad operandStack dan chiqadi). Natijaviy qiymat operandStack oxiridan qoshiladi.
Algoritm ikki fazani o`z ichiga oladi:
Faza I. Ifodani tekshirish.
Dastur ifodadagi operandlar, operatorlar va qavslarni chapdan-o`ngga qarab tekshiradi.

1. 
   Agar qaralayotgan qism operand bo`lsa, uni operandStack ga qo`shadi.
   
2. 
   Agar qaralayotgan qism operatorStack ning yuqorisida, yuqori mavqeyda bajarilayotgan barcha operatorlar kabi + yoki – operatori bo`lsa, bu operator stek oxiridan qoshib yoziladi.
   
3. 
   Agar qaralayotgan qism operatorStack ning yuqorisida, yuqori mavqeyda bajarilayotgan barcha operatorlar kabi * yoki / operatori bo`lsa, bu operator stek oxiridan qoshib yoziladi.
   
4. 
   Agar qaralayotgan qism ( belgisi bo`lsa, uni operatorStack ga qo`shadi.
   
5. 
   Agar qaralayotgan qism ( belgisi bo`lsa, operatorStack ning yuqori qismida ( belgisi ko`ringunga qadar barcha operatorlar qayta bajariladi.