STL Veri Yapısı - std::array

Giriş
Şu satırı dahil ederiz.

#include <array>

std::array çok basit bir sınıf. İçi şuna benziyor.

template<typename T, int size>
class array {

...
...
private:
  T elements[size]; // determined during compilation
}

Gerçek kod ise şöyle

template<class T, std::size_t N>
struct array;

Ya da şöyle

template<typename T, std::size_t N>
struct my_array {
  T array[N];
};

Aggregate
std::array aggregate olmayı garanti ediyor.

The conditions for an aggregate (8.5.1) shall be met.

Ancak bu sınıf POD değil. Şu kullanım şekli yanlış.

float * pos_begin = ...:
std::array<float,4> * r = reinterpret_cast<std::array<float,4>*> (pos0+(4*i));

Tanımlama
std::array sınıfının ikinci parametresi derleme zamanı (compile time) bir sabit bir olmalı.
Örnek
Şöyle yaparız.

const auto arraySize = 10;
std::array<int, arraySize> data;

Örnek
Şöyle yaparız.

std::array<int, 4> arr1;
std::array<float, arr1.size()> arr2;

Örnek
Aşağıdaki örnek hata verir çünkü arraySize const olsa bile sz'nin değeri derleme zamanında belli değildir.

int sz=10;
const auto arraySize = sz;
std::array<int, arraySize> data; //error 

Örnek
Bu örnek te hata verir.

void f(int n) {
  std::array<float,n> data2; // error: ‘n’ is not a constant expression
}

Örnek
Bu sabit eksi bir sayı verilse bile her derleyici yakalamayabilir.

std::array<int, -1> arr;

Bu yüzden en iyi yöntem bir typedef tanımlama. Şöyle yaparız.

typedef std::array<int, 255> Array;

Örnek
İki boyutlu dizi için şöyle yaparız.

template <class T, std::size_t X, std::size_t Y>
using My2DArray = std::array<std::array<T, Y>, X>;

Constructor  - aggreage initialization
Örnek
Dizinin tüm elemanları aynı tip olmalı. Şu kod derlenmez.

std::array arr = { 1, 2, 3.4 }; // error

Örnek
const diziyi ilklendirmek için initializer_list kullanarak şöyle yaparız.

const std::array<std::string, 5> choices = {
    "I don't like Coca-Cola...",
    "Sprite is ok I guess.",
    "Waayyyy too much sugar.",
    "Mountain Dew! Nice.",
    "Eww. People don't drink Pepsi these days, it ain't the 90's."
};

Constructor  - initializer_list

Örnek
Şöyle yaparız.

std::array<int, 10> a{2, 2, 2, 2, 2, 2, 2, 2, 2, 2};

Örnek
Şöyle yaparız.

std::array<int, 5> test()
{
  std::array<int, 5> values {{0, 1, 2, 3, 4}};
  return values;
}

Metoddan Dönme
Aynı std::vector gibi yapabiliriz. Şöyle yaparız

std::array<T, SIZE> foo() {
  std::array<T, SIZE> bar;
  // Initialization of bar members...
  return bar;
}

begin ve end metodu
begin() ve end() kullanılabilir.

#include <array>
std::array<int, 10000000> myArray;
// fill the array with data
std::sort(myArray.begin(); myArray.end()); // sorts data using default operator <

for ile dönülebilir.

std::array<int, 10> myArray = {8, 3, 6, 7};
for (const auto& element : myArray)
{
  std::cout << element << std::endl;
}

Sonuç olarak şunu alırız.

8
3
6
7
0
0
0
0
0
0

fill metodu
Şöyle yaparız.

std::array<int, 10> a; 
a.fill(2/*or any other value*/);

operator [] metodu
İmzası şöyle

constexpr const_reference operator[]( size_type pos ) const;

Örnek
const diziyi ilklendirmek için metod kullanarak şöyle yaparız.

typedef std::array<int, 255> Array;

const Array array = generateData();

Array generateData(){
  Array a;
  for(int i = 0; i < a.size(); i++) {
    initializeSomehowTo(a[i]);
  }
  return a;
}

Örnek - İki Boyutlu Array

Şöyle dolaşırız.

#include <array>

int main() {
    std::array<std::array<int, 3>, 4> ia;
    for (auto &row : ia){
        for (auto &col : row){
            col = 0;
        }
    }
}

Bu dizi şununla aynıdır.

int ia[3][4];