RAII

RAII

Resource Acquisition Is Initialization or RAII, is a C++ programming technique which binds the life cycle of a resource that must be acquired before use to the lifetime of an object. Examples:

• allocated heap memory

• thread of execution

• open socket, open file

• locked mutex, disk space, database connection—anything that exists in limited supply

Resource Acquisition is Initialisation (RAII) Explained — Tom Dalling

Non-RAII approach

#include <iostream>
using std::cout, std::endl,std::string,;

struct Resource{
    Resource()  { cout << "Resource created\n"; }
    ~Resource() { cout << "Resource destroyed\n"; }
};

int main (){
    Resource *r1 = new Resource;
    //maybe forget to delete or throw error
    delete r1;
    return 0;
}

Resource created
Resource destroyed

maybe we'll forget to delete or throw an error

we could use smart-pointers

int main (){
    std::unique_ptr<Resource> r1(new Resource);
    return 0;
}

Resource created
Resource destroyed

RAII

#include <iostream>
#include <fstream>
#include <sstream>
using std::cout, std::endl,std::string,std::cin,std::ifstream;

class OpenFile{
private:
    ifstream file;
    string filename;
public:
    OpenFile(const string fname):filename(fname){
        file.open(filename);
    }

    ~OpenFile(){
        cout << "deleting resource\n";
        file.close();
    }

    std::string readLine() {
        std::ostringstream oss;
        string line;
        while ( getline (file,line) )
            oss << line <<"\n";
        return oss.str();
    }
};

int main (){
    OpenFile file("example.txt");
    cout << file.readLine() << endl;
    return 0;
}

This is a line.
This is another line.

deleting resource

There are 3 parts to an RAII class:

• The resource is relinquished in the destructor (e.g. closing a file)

• Instances of the class are stack allocated

• Optional: The resource is aquired in the constructor (e.g. opening a file).

When it comes to opening and closing files, std::fstream already has an RAII type of design because it closes itself in its destructor.