C++ stack unwind és a SIGINT

Magyarázatként a kérdezőnek: a processz minden erőforrását a kerneltől kapja:

* memória címterületek (pl stack, heap)
* fájl elérések (nyitott fájlok)
* hálózati elérések (nyitott portok)
* stb.

A programon belüli C++ konstruktor viszont már nem a kernelhez fordul, hanem vagy a stacken vagy a heapen foglal helyet (ami a programban le van írva) úgy hogy a program magán belül menedzseli, hogy mi hova kerül a saját memóriaterületein belül.

Tehát ha nem szabadítasz fel egy objektumot, az a programon belüli szinten leakel, oprendszer szinten nem.

Oprendszer szinten csak annyi látszik, hogy a processz RAM használata nő. (Van egy trükk az oprendszerben, hogy a lefoglalt memória címterületek mögé csak akkor tesz valódi RAM-ot az oprendszer, amikor egy lapba 0-tól eltérőt ír az adott program. A foglalt címterület a VIRT, és a valóban mögétett RAM A RES a top program nézetben.)

Amikor leállítod a programot, akkor az oprendszer minden allokált erőforrást magától felszabadít. Ez Linuxon teljesen jól működik, lehet építeni rá. Ezért ha tudod, hogy a programod le fog állni nem feltétlenül kell még a fájlok bezárásával sem foglalkozni (nem szép gyakorlat, de működik). A programbeli objektumokat szintén felesleges felszabadítani. Persze ez sem feltétlenül szép. Ha például a programodat később egy másik program alrendszereként akarod használni, akkor már gond lehet ha egy lefutása után felszabadítatlan objektumok maradnak utána.

(Még a régi szép DOS-os időkben lehetett olyan, hogy egy program az oprendszert kikerülve közvetlen BIOS vagy egyéb hívásokkal foglalt tárterületet, azok be tudtak ragadni a program leállása után. A modern oprendszerekben ilyen már nincs. Vagy ha van, akkor az kernel bug :-)

Amit mindenképpen érdemes leállás előtt elvarrni, az az írt fájlok flusholása és lezárása. Ha nem történt flush a program kényszer-bezárása előtt, akkor félig írt fájlok maradhatnak a diszken. Ez az ami miatt érdemes lehet SIGINT handlert csinálni, de valójában ez is csak speciális programoknál érdekes, a legtöbb esetben a signallal leállított program esetén nem elvárt a konzisztens kimenet.

Ha normál leállás történik, akkor szerintem az összes nyitott fájlra lefut egy flush. Például az stdout-ra írt dolgok mindenképpen megjelennek a kimeneten legkésőbb a leálláskor, akkor is ha nincs flush a programban.

#include <iostream>
#include <csignal>

using namespace std;

// Foo egy Meyer singleton
class Foo {
    private:
    Foo() {
        cout << "Foo constructed" << endl;
    }
    ~Foo() {
        cout << "Foo destructed" << endl;
    }
    public:
    static Foo& getInstance() {
        static Foo f;
        return f;
    }
};

void signalHandler(int signum) {
   cout << "Interrupt signal (" << signum << ") received.\n";
   exit(signum);  
}

int main() {
    signal(SIGINT, signalHandler);
    Foo::getInstance();
    char a;
    std::cout << "Now exit with the X or press CTRL + C" << endl;
    cin >> a;

    return 0;
}