Muistityypit ja niiden elinajat¶

Sidonta voi tarkoittaa muuttujan liittämistä tiettyyn muistipaikkaan. Sidonnan alussa muistitila varataan muuttujalle, ja kun sidonta on valmis, muistitilaa vapautetaan. Jaksoa, jonka aikana muuttuja on sidottu tiettyyn muistipaikkaan, kutsutaan muuttujan elinkaareksi. C++:ssa ohjelmoija voi määritellä muuttujia, joilla on eri elinikä, mukaan lukien:

Staattiset muuttujat

static int globalVariable = 10; // Staattinen globaali muuttuja
void foo() {
      static int staticLocalVariable = 5; // Staattinen paikallinen muuttuja
}

Muuttujat, jotka esitellään “static” avainsanalla, ovat esimerkkejä staattisista muuttujista. C++:ssa staattinen muuttuja sidotaan muistipaikkaansa ennen ohjelman suorittamista, ja sidos säilyy koko suorituksen ajan. Aiemmissa C++:n versioissa kaikkia muuttujia pidettiin staattisina.

Pinodynaamiset muuttujat funktion sisällä

void bar() {
   int pinoMuuttuja = 7; // Pinodynaaminen paikallinen muuttuja
}

bar() suorittamisen jälkeen pinoMuuttuja tuhotaan pinosta, eikä sitä enää ole.

Eksplisiittiset kekodynaamiset muuttujat

int* dynaaminenMuuttuja = new int(42); // Eksplisiittinen keon dynaaminen muuttuja
delete dynaaminenMuuttuja; // Eksplisiittinen purku ennen ohjelman päättymistä

Eksplisiittinen muistinvaraus komennolla new tai malloc.

void bar() {
   int* dynaaminenMuuttuja = new int(42); // Eksplisiittinen keon dynaaminen muuttuja
}

Mikään eksplisiittinen poistaminen tai keon muistin poistaminen ei johda muistivuotoon. Mielellään poisto tehdään samassa skoopissa, missä muuttuja määriteltiin.

Epäsuorat keon dynaamiset muuttujat

C++:ssa implisiittisiä dynaamisia muuttujia voidaan luoda esimerkiksi seuraavalla tavalla:

std::vector<int>v = {0};

Koodinpätkä varaa muistia heapissa sijaitsevalle int-taulukolle. Vektori käsittelee muistin varaamisen ja vapauttamisen sisäisesti, mikä helpottaa käyttäjän työskentelyä taulukoiden kanssa ilman nimenomaista muistinhallintaa.

Kuinka voit itse tarkastella pinon ja heapin käyttöä:

#include <iostream>
#include <vector>

using namespace std;

int main()
{

   // memory usage examples
   // stack
   int i = 42;
   int* stack_i = &i;
   // heap
   int* heap_i = new int(69);

   cout << "stack_i: " << stack_i << " heap_i: " << heap_i << std::endl<< std::endl;


   // heap or stack?: an array with one value
   int arr[1] = {0};
   int* arr_ptr = &arr[0];
   std::vector<int>v = {0};

   // stack
   cout << "arr_ptr: " << arr_ptr << std::end;
   // stack
   cout << "v_ptr: " << &v << std::endl;
   // heap!
   cout << "  The content of vector: " << &v.front() << endl;

   delete heap_i;
   return 0;
}

Ohjelma tulostaa:

Pino-muistiosoitteet alkavat 0x7ff*-tavuilla, kun taas heap-muistiosoitteet alkavat 0x56*-tavuilla. Taulukon arr sisältö on staattista, joten se tallentaan pinoon.

Itse vektoriobjekti (+ metatiedot) sijoitetaan pinoon, mutta vaikka vektori on pinossa, sen dynaaminen sisältö (kokonaislukutaulukko) on keossa.

Ulkoiset muuttujat

C++ tukee myös ulkoisia viittauksia (esim. “extern”-avainsana) ja tiedostoissa olevia pysyviä tietoelementtejä, jotka säilyvät ohjelman suorituksen päätyttyäkin. Näin ollen muuttujan elinikä voi olla pidempi kuin ohjelman ajonaika.

Muistinhallinnan parhaat käytännöt¶

1. Vältä iteraattorin mitätöintiä:

   • ole varovainen iteraattorin mitätöimisen suhteen, kun muokkaat säilöjä (esim. lisäät tai poistat)

2. Käytä älykkäitä osoittimia:

   • “std::unique_ptr” ja “std::shared_ptr” hallitsevat muistia automaattisesti

#sisällytä <muisti>
std::ainutlaatuinen_ptr<int> ainutlaatuinenPtr = std::make_unique<int>(42);

3. suosi STL-säilöjä ja algoritmeja:

   • kuten “std::vector”, “std::map” ja STL-algoritmit aina kun mahdollista.

4. Vältä keon muistin varaamista kokonaan, jos mahdollista:

   • minimoi “new”, “delete”, “malloc” ja “free” käyttö.
   • Muista poistaa ja antaa selkeät menetelmät resurssien vapauttamiseksi

5. Profiloi ja testaa:

   • Käytä Valgrindia! (valgrind –quiet –leak-check=full ./a.out )

Valgrindin virheilmoitukset¶

Joissakin virheilmoituksissa esiintyy numeroita 1, 4, 8. Luvut tarkoittavat tyypin tarvitseman muistialueen kokoa tavuina. Merkkityypille (char) riittää yksi tavu, kokonaisluku (int) tarvitsee neljä tavua ja osoittimet kahdeksan.

Valgrind kertoo sarakkeessa Location tiedoston ja rivinumeron. Kyseinen kohta on se, missä virhe ilmenee tai missä se havaitaan. Korjattava koodikohta voi olla jossakin muualla (jossakin kohdassa, joka suoritettiin ennen virheen havaitsemiskohtaa).

Seuraavaksi käydään läpi joitakin yleisimpiä virheilmoituksia.

int* new_int;

std::cout << *new_int;

int* new_item = nullptr;

delete item_to_be_removed;
...
cout << item_to_be_removed->task << endl;

delete item_to_be_removed;
...
delete item_to_be_removed;

delete item_to_be_removed;
item_to_be_removed = nullptr;
...
delete item_to_be_removed;

N (…) bytes in M blocks are definitely lost in loss record X of Y¶

Muistia jää vapauttamatta, eli delete-komento unohtui.

Ohjelma voi silti toimia oikein, eli virhettä on vaikea havaita ilman valgrindia.

TIRAKA-fall2023 tavallisimmat virheet¶

Vuoden 2023 Valgrind-tulokset vahvistavat aiemmat tulokset siitä, että muistivuodot ovat merkittävin virhelähde, kuten alla olevasta kuvasta ilmenee:

Pääasialliset syyt muistivuodoille ovat new-operatorin (muisti) virheellinen käyttö.

Jossain määrin meillä oli myös uusi virheluokka, nimeltään irreflexive requirements.

struct Person {
   std::string name="";
   int age=0;
};

bool ageComparator(const Person& p1, const Person& p2) {
   return p1.age < p2.age;
}

std::set<Person, decltype(&ageComparator)> peopleSet(&ageComparator);

std::set<Person, [](const Person& p1, const Person& p2) {
   return p1.age < p2.age;
}> peopleSet;

/* Functor */
struct AgeComparator {
   bool operator()(const Person& p1, const Person& p2) const {
      return p1.age < p2.age;
   }
};

std::set<Person, AgeComparator> peopleSet;