public:

template <typename... Args>

explicit constexpr NoDestructor(Args&&... args)

: impl_(std::in_place, std::forward<Args>(args)...) {}

NoDestructor(const NoDestructor<T>&) = delete;

NoDestructor(NoDestructor<T>&&) = delete;

NoDestructor<T>& operator=(const NoDestructor<T>&) = delete;

NoDestructor<T>& operator=(NoDestructor<T>&&) = delete;

T& get() { return impl_.get(); }

const T& get() const { return impl_.get(); }

T& operator*() { return get(); }

const T& operator*() const { return get(); }

T* operator->() { return std::addressof(get()); }

const T* operator->() const { return std::addressof(get()); }

private:

class TrivialImpl final {

public:

template <typename... Args>

explicit constexpr TrivialImpl(std::in_place_t, Args&&... args)

: value_(std::forward<Args>(args)...) {}

T& get() { return value_; }

const T& get() const { return value_; }

private:

T value_;

};

class PlacementImpl final {

public:

template <typename... Args>

explicit PlacementImpl(std::in_place_t, Args&&... args) {

::new (static_cast<void*>(&value_)) T(std::forward<Args>(args)...);

}

T& get() { return *std::launder(reinterpret_cast<T*>(&value_)); }

const T& get() const {

return *std::launder(reinterpret_cast<const T*>(&value_));

}

private:

alignas(T) uint8_t value_[sizeof(T)];

};

std::conditional_t<std::is_trivially_destructible_v<T>, TrivialImpl,

PlacementImpl>

impl_;