# Använder du STL array på rätt sätt

11 juli 2025 | https://www.ribomation.se/blog/2025/anvander-du-stl-array-pa-ratt-satt/

I min förra artikel beskrev jag ingående användning av std::vector. I denna artikel, tar jag upp vad du behöver veta om dess lillebror std::array. Den avgörande skillnaden mellan dessa två är std::vector består av ett heap-allokerat minnesblock som omallokeras i takt med att fler element sätts in, medan std::array saknar rörliga delar utan består av ett statiskt minnesblock där objektet är placerat, vanligtvis på stack:en.

Du skapar ett std::array objekt med två template parametrar, den första är element-typen, precis som för std::vector, och den andra är vilken storlek eller kapacitet den ska ha.

```cpp
#include <array>
//...
auto a = std::array<int, 6>{1,2,3};
std::println("{} ({}, {})", a, a.size(), a.empty());
//prints: [1, 2, 3, 0, 0, 0] (6, false)
```

Här har jag skapat en med plats för 6 element, initierat de 3 första och låtit default-initiera de övriga. Eftersom storleken är fixerad, så har man föga nytta av metoderna size() respektive empty(). Enda gången den sistnämnda returnerar true, är när man skapat en array med storlek 0; men vad ska man med en sådan till?

```cpp
auto a = std::array<int, 1>{};
std::println("a: {} ({})", a, a.empty());  //prints: a: [0] (false)
auto b = std::array<int, 0>{};        
std::println("b: {} ({})", b, b.empty());  //prints: b: [] (true)
```

Om du inte vill initiera array:en, kan du populera den via t.ex. en for-loop.

```cpp
auto a = std::array<int, 5>{};
std::println("{}", a);  //prints: [0, 0, 0, 0, 0]
for (auto k = 0U; k < a.size(); ++k) a[k] = (k+1)*10;
std::println("{}", a);  //prints: [10, 20, 30, 40, 50]
```

Precis som med std::vector, ska du vara försiktigt med hur du accessar enskilda element. Använder du index-operatorn, så finns inga gränskontroller, vilket är ok om du kontrollerar mot metoden size().

```cpp
auto a = std::array<int, 3>{1,2,3};
int  b[]{10,20,30};
std::println("a: {} @ {}", a, reinterpret_cast<size_t>(a.data()));
//prints: a: [1, 2, 3] @ 140721718715856
std::println("b: {} @ {}", b, reinterpret_cast<size_t>(&b));
//prints: b: [10, 20, 30] @ 140721718715872
a[2] = 33;
a[3] = 44;
a[4] = 55;
a[5] = 66;
std::println("a: {}, b: {}", a, b); //prints: a: [1, 2, 33], b: [55, 66, 30] 😮
```

Om du vill ha gränskontroll, använd då metoden at() i stället, som kastar ett exception om du försöker nå ett element som inte finns.

```cpp
try {
    auto a = std::array<int, 3>{1,2,3};
    std::println("a.at(5): {}", a.at(5)); //boom
} catch (std::exception& x) { 
    std::println("ERR: {}", x.what()); //prints: ERR: array::at: __n (which is 5) >= _Nm (which is 3)
}
```

Samtliga kodsnuttar ovan finns att kika på Compiler Explorer:

 [![Compiler Explorer](/images/compiler-explorer-logo.svg "Compiler Explorer - Try it yourself") Try it yourself on Compiler Explorer](https://godbolt.org/z/7fK4df9E7)