#include <iostream>

struct foo {
    ~foo() {
        std::cout << "~foo()\n";
    }
};

struct foo_holder {
    const foo &f;
};

int main() {
    foo_holder holder = { foo() };
    std::cout << "done!\n";
    return 0;
}

~foo()
done!

The storage duration of member subobjects, base class subobjects and array elements is that of their complete
object (1.8).

12.2 Temporary objects
4. There are two contexts in which temporaries are destroyed at a different point than the end of the fullexpression.
The first context is when an expression appears as an initializer for a declarator defining an
object. In that context, the temporary that holds the result of the expression shall persist until the object’s
initialization is complete. The object is initialized from a copy of the temporary; during this copying, an
implementation can call the copy constructor many times; the temporary is destroyed after it has been
copied, before or when the initialization completes. If many temporaries are created by the evaluation of
the initializer, the temporaries are destroyed in reverse order of the completion of their construction.
191
ISO/IEC 14882:2003(E)  ISO/IEC
12.2 Temporary objects 12 Special member functions
5 The second context is when a reference is bound to a temporary. The temporary to which the reference is
bound or the temporary that is the complete object to a subobject of which the temporary is bound persists
for the lifetime of the reference except as specified below. A temporary bound to a reference member in a
constructor’s ctor-initializer (12.6.2) persists until the constructor exits. A temporary bound to a reference
parameter in a function call (5.2.2) persists until the completion of the full expression containing the call.
A temporary bound to the returned value in a function return statement (6.6.3) persists until the function
exits. In all these cases, the temporaries created during the evaluation of the expression initializing the reference,
except the temporary to which the reference is bound, are destroyed at the end of the full-expression
in which they are created and in the reverse order of the completion of their construction. If the lifetime of
two or more temporaries to which references are bound ends at the same point, these temporaries are
destroyed at that point in the reverse order of the completion of their construction. In addition, the
destruction of temporaries bound to references shall take into account the ordering of destruction of objects
with static or automatic storage duration (3.7.1, 3.7.2); that is, if obj1 is an object with static or automatic
storage duration created before the temporary is created, the temporary shall be destroyed before obj1 is
destroyed; if obj2 is an object with static or automatic storage duration created after the temporary is created,
the temporary shall be destroyed after obj2 is destroyed.

A temporary bound to a reference in a new-initializer (5.3.4) persists until the completion of the
full-expression containing the new-initializer. [ Example:

struct S { int mi; const std::pair<int,int>& mp; };
S a { 1, {2,3} };
S* p = new S{ 1, {2,3} }; // Creates dangling reference

—end example ] [ Note: This may introduce a dangling reference, and implementations are encouraged
to issue a warning in such a case. —end note ]

_>~foo()
_>done!
_>

int main() {
    std::cout << "~foo()\n";
    std::cout << "done!\n";
    return 0;
}

_>~foo()
_>done!
_>

#include <iostream>

struct X
{
    ~X()
    {
        std::cout << "~X()\n";
    }
};

struct Y {
    Y() : ref(X()) { std::cout << "Y()\n"; }
    X const &ref;
};

int main()
{
    Y y;
}

done!
~foo()

Y()
~X()

The temporary to which the reference is bound or the temporary that is the complete object to a subobject of which the temporary is bound persists for the lifetime of the reference except as specified below.

#include <iostream>

struct X
{
    X() { std::cout << "X()\n"; }
    ~X() { std::cout << "~X()\n"; }
};

struct T
{
    T(X const &) {}
};

void f(X const &) {}

void g()
{
    std::cout << "f()\n";
}

int main()
{
    ( f(X()), g() ); // время жизни временного объекта типа X - full-expression
    ( T(X()), g() ); // должно быть аналогично предыдущему, но в правилах это не прописано
}

Foo GetFoo()
{
Foo f;
return f;
}
const Foo &const_ref_to_f = GetFoo();