Is the address of a std::optional's value stable?

Question

Say I have a std::optional<T>. I reset and assign the value multiple times. Is the address of the value (when present) always the same for a given optional?

In other words:

#include <cassert>
#include <optional>
#include <string>

template<typename T>
auto test()
{
    auto opt = std::optional<T>{T{}};
    auto* ptr = &*opt;

    opt.reset();
    opt = T{};

    assert(ptr == &*opt); // Can this assert fail?
}

int main()
{
    test<int>();
    test<double>();
    test<std::string>();
    // ...
}

Does the standard guarantee the stability of the address of the value?

Answer 1

Does the standard guarantee the stability of the address of the value?

From my point of view, it is unspecified whether the address is stable or not.

Formally, the standard only guarantees that there are no dynamic allocations for the object contained within std::optional and the containing object is stored as a part of std::optional:

23.6.3 Class template optional [optional.optional]

Any instance of optional at any given time either contains a value or does not contain a value. When an instance of optional contains a value, it means that an object of type T, referred to as the optional object’s contained value, is allocated within the storage of the optional object. Implementations are not permitted to use additional storage, such as dynamic memory, to allocate its contained value. The contained value shall be allocated in a region of the optional storage suitably aligned for the type T. When an object of type optional is contextually converted to bool, the conversion returns true if the object contains a value; otherwise the conversion returns false.

The actual storage mechanism is defined by a particular implementation, so, potentially, the address might change.

In practice, however, implementations will be using something like aligned_storage (see boost implementation) or union (as gcc does) and keep an address of the containing object the same.