gul14::FinalAction< F > Class Template Reference

Detailed Description

template<typename F>
class gul14::FinalAction< F >

FinalAction allows us to execute something if the FinalAction object leaves the scope.

A FinalAction can be used to add RAII like behavior for non RAII object or to do timing measurements.

To generate this object you can use the function finally, that leverages template argument deduction of the action's type. This simplifies instantiation a lot.

(Implementation is quite similar to what's in the Guideline-Support-Library.)

A good example is function call duration measurement. The FinalAction just needs to be created in the beginning of a function and no hassle with diverse possible return points.

#include <cstdlib>
#include <ctime>
#include <gul14/gul.h>
 
using gul14::finally;
using gul14::sleep;
using gul14::tic;
using gul14::toc;
 
void foo() {
    auto _ = finally([start = tic()] {
        std::cerr << "Function foo() took " << toc(start) << " s.\n";
    });
 
    std::srand(std::time(nullptr));
    if (std::rand() % 2) {
        std::cout << "Premature exit\n";
        return;
    }
    sleep(10); // do important stuff (like sleeping)
    std::cout << "Normal exit\n";
}

A (bad; use containers instead) example is allocation with RAII:

#include <new>
#include <string>
#include <gul14/gul.h>
 
using gul14::finally;
 
std::string bar(float some_float) {
    char* buffer = new char[100];
    if (buffer == nullptr)
        return;
    auto _ = finally([&] { delete[] buffer; buffer = nullptr; });
 
    // do stuff that might throw here
 
    snprintf(buffer, 100, "%.1f", some_float);
    return { buffer };
    // get rid of buffer automagically
}

Template Parameters

F	The type of the closure/function to be called.

Since

GUL version 1.1

#include <finalizer.h>

Public Member Functions
	FinalAction (F f) noexcept
	Creates a new FinalAction object. More...
	FinalAction (FinalAction &&other) noexcept
	Move constructor.
FinalAction &	operator= (FinalAction &&other) noexcept
	Move assignment operator.
	FinalAction ()=delete
	FinalAction is not is_default_constructible.
	FinalAction (const FinalAction &)=delete
	FinalAction is not copyable.
FinalAction &	operator= (const FinalAction &)=delete
	FinalAction is not copyable.
	~FinalAction () noexcept
	Destructor Calls action except when in move contexts.

Constructor & Destructor Documentation

FinalAction()

template<typename F >

gul14::FinalAction< F >::FinalAction ( F  f )

inlineexplicitnoexcept

Creates a new FinalAction object.

It takes any callable as action to be called when the FinalAction destructs (lifetime ends / leaves the scope).

The template parameter F has to be specified; this can be avoided by using the convenience function finally.

Template Parameters

F	The type of the closure/function to be called.

Parameters

f	The closure or function to be called on destruction.

---

The documentation for this class was generated from the following file:

• finalizer.h