# Initialiserar du på rätt sätt i C++?

15 maj 2025 | https://www.ribomation.se/blog/2025/initialiserar-du-pa-ratt-satt-i-c++/

### Initiering i Modern C++

Ett av de mest förbisedda, men samtidigt viktigaste ämnena i C++, är initiering. Hur vi väljer att initiera våra variabler påverkar inte bara korrektheten i programmet, utan även läsbarhet, säkerhet och förutsägbarhet. Med Modern C++ har vi fått en hel verktygslåda med förbättrade sätt att initiera värden — från enkla variabler till komplexa objekt och containrar. I denna artikel visar jag varför det är viktigt, samt illustrerar med flera konkreta exempel.

### Varför initiering spelar roll

Alla som har jobbat i C++ ett tag vet att oinitierade variabler kan vara en tickande bomb. Ett vanligt exempel:

```cpp
int count;
if (count > 0) { ... } // Undefined behaviour
```

Detta är både farligt och svårt att felsöka. Genom att alltid initiera variabler får vi mer robust kod och slipper subtila buggar.

### Klassisk initiering

Traditionellt har man initierat med tilldelning eller med parenteser:

```cpp
int a = 42;
double pi(3.1415);
std::string name = "Anna";
```

Detta fungerar, men med Modern C++ (från C++11 och framåt) föredrar man ofta uniform initialization med klamrar:

```cpp
int a{42};
double pi{3.1415};
std::string name{"Anna"};
```

Det blir även bättre med `auto`.

```cpp
auto a{42};
auto pi{3.1415};
auto name = std::string{"Anna"};
```

Det ser kanske trivialt ut, men skillnaden är viktig. Med klammerinitiering undviker man vissa problem med narrowing conversions, t.ex.:

```cpp
int x1 = 3.14;    // Tillåtet, men förlorar information
int x2{3.14};     // Kompileringsfel: narrowing
```

### STL-containrar

När vi initierar standardcontainrar, så blir det ofta mycket tydligare med klamrar:

```cpp
#include <vector>
#include <string>
#include <map>

auto numbers = std::vector<int>{1, 2, 3, 5, 8, 13};
auto greetings = std::vector<std::string>{"Hej", "Tjena", "Goddag"};

auto scores = std::map<std::string, int>{
    {"Anna", 92}, {"Bertil", 85}, {"Cecilia", 98}
};
```

Koden ovan är både kompakt och lätt att läsa. Alternativet hade varit ett antal push\_back och insert-anrop.

### Initiering av pekare och new

Med auto och klammerinitiering blir kod med dynamiska allokeringar också renare:

```cpp
auto p1 = new int{42};
auto p2 = new std::string{"Modern C++"};
auto p3 = std::make_unique< std::vector<int> >(std::initializer_list<int>{1, 2, 3});
```

Särskilt när man använder smarta pekare (vilket man alltid bör göra nuförtiden) så är klamrar att föredra.

### Konstruktor- och medlems initiering

När man skriver egna klasser, så kan man använda klammerinitiering även i konstruktorslistor:

```cpp
class Person {
    std::string name;
    int age;
  public:
    Person(std::string n, int a) : name{std::move(n)}, age{a} {}
};
```

Från och med C++11 kan man också initiera medlemmar direkt vid deklarationen:

```cpp
class Account {
    std::string  number{"ABC-123"};
    int          balance{0};
};
```

Detta gör det lättare att se default-värden, utan att behöva bläddra till konstruktorn.

### Funktioner med initieringslistor

En elegant detalj med C++11 och framåt är att man kan använda klammerinitiering direkt i funktionsanrop:

```cpp
void print_sum(std::initializer_list<int> values) {
    auto sum = 0;
    for (auto v : values) sum += v;
    std::cout << "Summa: " << sum << "\n";
}

print_sum( {10, 20, 30, 40} );
```

Detta fungerar tack vare `std::initializer_list`, som många STL-funktioner också stöder.

### Strukturbindning + initiering

Kombinera initiering med strukturbindning (från C++17), och du får mycket elegant kod:

```cpp
#include <tuple>
#include <string>

auto get_person() -> std::tuple<std::string, int> {
    return {"Dora Explorer", 7};
}

auto [name, age] = get_person();
std::cout << name << " är " << age << " år\n";
```

### Avslutande reflektioner

Modern C++ har förändrat hur vi skriver initieringskod — till det bättre. Med uniform initiering, auto, strukturbindningar och initializer\_list blir våra program tydligare, säkrare och mer uttrycksfulla. Jag rekommenderar starkt att gå över till klammerinitiering i så stor utsträckning som möjligt.

Det är ett enkelt sätt att modernisera sin kodbas — och din framtida jag kommer att tacka dig.

Min katt, C++, föredrar också klammerinitiering. Men det är mest för att han gillar att ligga och sova på {}-tangenterna.