absl::NoDestructor

template<typename T>
class NoDestructor;

Description

An instance of absl::NoDestructor<T> has similar type semantics to an instance of T:

* Constructs in the same manner as an object of type T through perfect forwarding. * Provides pointer/reference semantic access to the object of type T via ->, *, and get(). (Note that const NoDestructor<T> works like a pointer to const T.)

Additionally, NoDestructor<T> provides the following benefits:

* Never calls T's destructor for the object * If the object is a function-local static variable, the type can be lazily constructed.

An object of type NoDestructor<T> is "trivially destructible" in the notion that its destructor is never run.

Usage as Function Scope Static Variables

Function static objects will be lazily initialized within static storage:

// Function scope. const std::string& MyString() { static const absl::NoDestructor<std::string> x("foo"); return *x; }

For function static variables, NoDestructor avoids heap allocation and can be inlined in static storage, resulting in exactly-once, thread-safe construction of an object, and very fast access thereafter (the cost is a few extra cycles).

Using NoDestructor<T> in this manner is generally better than other patterns which require pointer chasing:

// Prefer using absl::NoDestructor<T> instead for the static variable. const std::string& MyString() { static const std::string* x = new std::string("foo"); return *x; }

Usage as Global Static Variables

NoDestructor<T> allows declaration of a global object of type T that has a non-trivial destructor since its destructor is never run. However, such objects still need to worry about initialization order, so such use is not recommended, strongly discouraged by the Google C++ Style Guide, and outright banned in Chromium. See https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables

// Global or namespace scope. absl::NoDestructor<MyRegistry> reg{"foo", "bar", 8008};

Note that if your object already has a trivial destructor, you don't need to use NoDestructor<T>.