C++ std::array

C++ tilida std::array - belgilangan o'lchamdagi massivlarni qamrab oluvchi konteyner sinfidir. U C-style arrays ga o'xshaydi, chunki u o'xshash turdagi bir nechta qiymatlarni saqlaydi.

C++ std::massiv deklaratsiyasi

std::array <array> sarlavhasida aniqlangan, shuning uchun std::array dan foydalanishdan oldin ushbu sarlavhani kiritishimiz kerak.

Sintaksis

#include <array>

// std::array deklaratsiyasi
std::array<T, N> array_name;

qayerda,

• T - saqlanadigan element turi
• N - massivdagi elementlar soni

Raqamlar ro'yxatini saqlaydigan 5 o'lchamdagi std::array ni qanday e'lon qilamiz:

std::array<int, 5> numbers;

std::arrayni ishga tushirish

std::array -ni ikkita usulda ishga tushirishimiz mumkin:

1-usul:

// ishga tushirish ro'yxati
std::array<int, 5> numbers = {1, 2, 3, 4, 5};

2-usul:

// yagona ishga tushirish
std::array<int, 5> marks {10, 20, 30, 40, 50};

Bu erda biz raqamlar deb nomlangan ikkita massivni ishga tushirdik va int tipidagi elementni saqlaydigan 5 o'lchamli ikkalasini belgiladik.

Misol: C++ std::massiv

// std::massivlardan foydalanishni ko'rsatish uchun C++ dasturi

#include <iostream>
#include <array>

using namespace std;

int main(){
    // yagona ishga tushirish
    array <int , 5> numbers {1, 2, 3, 4, 5};

    cout << "The elements are: " << endl;

    // qismlarni chop etish uchun intervalli for loop dan foydalanish
    for(const int num: numbers){
        cout << num << " ";
    }
}

Chiqish

The elements are: 
1 2 3 4 5

Yuqoridagi misolda biz yagona ishga tushirishdan foydalangan holda std::array nomli raqamlarni e'lon qildik va ishga tushirdik.

array <int , 5> numbers {1, 2, 3, 4, 5};

Keyin biz ranged for loop yordamida massiv tarkibini ko'rsatdik.

std::array elementlariga kirish

Biz massiv elementiga [] operatori va massiv elementi indeksi yordamida kirishimiz mumkin.

// 5 ta butun sonli massiv
std::array<int, 5> n = {1, 2, 3, 4, 5};

// birinchi massiv elementiga kirish
std::cout << n[0] // 1 qaytaradi

// ikkinchi massiv elementiga kirish
std::cout << n[1] // qaytaradi 2

[!NOTE] [] operatori yordamida elementlarga kirish chegaradan tashqari xatolikni tekshirmaydi. Chegaradan tashqari xato dastur ruxsat etilgan diapazondan tashqaridagi ma'lumotlarga kirishga harakat qilganda yuzaga keladi. Masalan, bizda 5 ta elementdan iborat massiv bor va biz 10-elementga kirishga harakat qilamiz, bu chegaradan tashqari xato.

Massiv elementiga kirishning yana bir usuli chegaradan tashqari xatolikni tekshiradigan at usulidan foydalanishdir.

// 5 ta butun sonli massiv
std::array<int, 5> n = {1, 2, 3, 4, 5}; 
std::cout << n.at(0) // 1 qaytaradi
std::cout << n.at(1) // qaytaradi 2
std::cout << n.at(10) // std::out_of_range istisnosini chiqaradi

std::array elementlarini o'zgartirish

Muayyan indeksdagi elementni o'zgartirish uchun biz yana [] va at dan foydalanishimiz mumkin.

std::array<int, 5> marks = {50, 67, 88, 98, 34};

// 3-elementni [] yordamida o'zgartiring
marks[2] = 76; 

// at yordamida birinchi elementni o'zgartiring
n.at(0)= 1;

Misol: Massiv elementlarini o'zgartirish va ularga kirish

#include <iostream>
#include <array>

using namespace std;

int main(){
    array <int, 5> numbers = {1, 2, 3, 4, 5};

    // [] operatori yordamida kirish
    cout << "First element: " << numbers[0] << '\n';

    // at usuli yordamida kirish
    cout << "Second element: " << numbers.at(1) << '\n';

    // 0 indeksidagi elementni o'zgartiring
    numbers[0] = 8;

    cout << "Modifying first element: " << numbers[0] << '\n';

    // 1 indeksidagi elementni o'zgartiring
    numbers.at(1) = 90;

    cout << "Modifying second element: " << numbers[1] << '\n';
}

Chiqish

First element: 1
Second element: 2
Modifying first element: 8
Modifying second element: 90

Yuqoridagi misol [] operatori va std::array elementlariga kirish va o'zgartirish uchun at usulidan foydalanishni ko'rsatadi.

Massiv bo'sh yoki yo'qligini tekshiring

Massiv bo'sh yoki yo'qligini tekshirish uchun biz empty() usulidan foydalanishimiz mumkin:

// n std::massiv bo'lsin
n.empty()

empty usuli massiv bo'sh bo'lganda rost, aks holda yolg'onni qaytaradi.

Massivdagi elementlar sonini oling

Massivdagi elementlar sonini olish uchun size usulidan foydalanishimiz mumkin.

// n std::massiv bo'lsin
n.size() // massiv hajmini qaytaradi

Misol: std::array bilan bo'sh va o'lcham usulidan foydalanish

#include <iostream>
#include <array>
using namespace std;

int main(){
    array <int, 5> numbers = {1, 2, 3, 4, 5};

    cout << "The size of array is: " << numbers.size() << '\n';

    if(numbers.empty()){
        cout << "The array is empty";
    }
    else{
        cout << "The array is not empty";
    }
}

Chiqish

The size of array is: 5
The array is not empty

Yuqoridagi misolda biz massiv bo'sh yoki yo'qligini tekshirish uchun empty usulidan va massivdagi elementlar sonini olish uchun size usulidan foydalandik.

std :: massivini bir xil qiymat bilan to'ldiring

Xuddi shu qiymatga ega butun massivni fill qilish uchun to'ldirish usulidan foydalanishimiz mumkin.

Keling, bir misolni ko'rib chiqaylik.

#include <iostream>
#include <array>

using namespace std;

int main(){
    array<int, 5> a;

    // massivni nol bilan to'ldiring
    a.fill(0);
  
    cout << "The elements are: ";
    for(const int& elt: a){
        cout << elt << " ";
    }
}

Chiqish

The elements are: 0 0 0 0 0

Bu erda biz butun massivni 0 bilan to'ldirish uchun a.fill(0) dan foydalandik.

Misol: STL algoritmlari bilan std::massivdan foydalanish

C++ tilida biz Standard Template Library dan ba'zi tez-tez ishlatiladigan algoritmlarni amalga oshirish uchun foydalanishimiz mumkin. Ushbu algoritm std::array ni juda yaxshi qo'llab-quvvatlaydi. Masalan,

#include <iostream>
#include <algorithm>
#include <numeric>
#include <array>

using namespace std;

int main(){
    array<int, 5> age = {45, 23, 66, 87, 21};

    // saralash
    sort(age.begin(), age.end());

    // tartiblangan massivni chop eting
    cout << "The sorted array is: ";
    for(const int elt: age){
        cout << elt << " ";
    }
    cout << endl;

    // qidirish
   // 5 raqami bor yoki yo'qligini tekshirish
    auto found = find(age.begin(), age.end(), 5);

    if (found != age.end()) cout << "5 was Found" << endl;
    else cout << "5 was Not Found" << endl;

    // jamlash
    int sum = accumulate(age.begin(), age.end(), 0);

    cout << "The sum of the element of array is : " << sum;
}

Chiqish

The sorted array is: 21 23 45 66 87 
5 was Not Found
The sum of the element of array is : 242

Bu erda biz massivda 3 xil amalni bajardik: saralash, qidirish va yig'ish.

Massivni saralash uchun biz sort() funksiyasidan foydalandik.

sort(age.begin(), age.end());

Bu massivni birinchi elementdan oxirigacha tartiblaydi.

Massivdagi elementni qidirish uchun biz find() funksiyasidan foydalandik.

// 5 raqami bor yoki yo'qligini tekshiring
auto found = find(age.begin(), age.end(), 5);

Bu yerda find funksiyasi 5 raqami massiv yoshida bo'lsa, qidiradi. Natija topilgan o'zgaruvchida saqlanadi. Agar topilgan age.end() ga teng bo'lsa, raqam mavjud emas; aks holda, shunday.

Massiv elementlari yig'indisini topish uchun biz std::accumulate funksiyasidan foydalanamiz.

int sum = std::accumulate(age.begin(), age.end(), 0);

Bu butun massiv raqamlarining yig'indisini qaytaradi.

std::array va C uslubidagi massiv o'rtasidagi farqlar quyidagilardir: T[n] C uslubidagi massiv avtomatik ravishda T* ga uzatishi mumkin, std::array esa. std::array<T, N> qo'llab-quvvatlasa, C uslubidagi massiv tayinlashni qo'llab-quvvatlamaydi. int a[5] = {1, 2, 3, 4, 5}; // Error: invalid array assignment int b[5] = a[5]; std::array<int, 5> a = {1, 2, 3, 4, 5}; // Correct: std::array supports assignment std::array<int, 5> b = a; Bundan tashqari, std::array C uslubidagi massivga nisbatan STL konteynerining barcha afzalliklarini ta'minlaydi. Shunday qilib, std::array dan C++ da C uslubidagi massivdan foydalanish tavsiya etiladi.