The temporary to which the reference is bound or the temporary that is the complete object of a subobject to which the reference is bound persists for the lifetime of the reference except: [...]

__declspec(dllimport) X *dll_func(X &&, X *);

int main()
{
    auto &&x = static_cast<X &&>(*dll_func(X(), new X));
    ....
}

const base& obj = true ? (const base&)d1() : (const base&)d2();

— An rvalue (so called, historically, because rvalues could appear on the right-hand side of an assignment
expression) is an xvalue, a temporary object (12.2) or subobject thereof, or a value that is not associated
with an object.

— A prvalue (“pure” rvalue) is an rvalue that is not an xvalue.

int &&x = 1;

class base { virtual void f() const = 0;};
class d1 : public base { void f() const override {...} };
class d2 : public base { void f() const override {...} };

const base& obj = true ? (const base&)d1() : d2();
obj.f();

if true
  d1().f();
else
  d2().f();

T>if true
T>  d1().f();
T>else
T>  d2().f();
T>

[&](base &&x)
{
    x.f();
}(true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));

auto f = [&](auto &&x)
{
    x.f();
};
if(true) f(d1()); else f(d2());

EP>[&](base &&x)
EP>{
EP>    x.f();
EP>}(true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));
EP>

base && x = (true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));
x.f() ?

EP>>[&](base &&x)
EP>>{
EP>>    x.f();
EP>>}(true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));
EP>>

T>base && x = (true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));
T>x.f() ?
T>

#include <iostream>

struct B
{
    virtual ~B() { std::cout << "~B()" << std::endl; }
    virtual void f() = 0;
};

struct D1 : B
{
    D1() { std::cout << "D1()" << std::endl; }
    ~D1() { std::cout << "~D1()" << std::endl; }
    void f() { std::cout << "D1::f" << std::endl; }
};

struct D2 : B
{
    D2() { std::cout << "D2()" << std::endl; }
    ~D2() { std::cout << "~D2()" << std::endl; }
    void f() { std::cout << "D2::f" << std::endl; }
};

int main()
{
    struct BRef
    {
        B &ref;
    };
    struct D1Wrapper
    {
        D1Wrapper() : value(), ref{value} {}
        D1 value;
        BRef ref;
    };
    struct D2Wrapper
    {
        D2Wrapper() : value(), ref{value} {}
        D2 value;
        BRef ref;
    };
    auto &&bref_1 = true ? D1Wrapper().ref : D2Wrapper().ref;
    auto &&bref_2 = false ? D1Wrapper().ref : D2Wrapper().ref;
    bref_1.ref.f();
    bref_2.ref.f();
}

// продлеватели жизни на все случаи
std::optional<d1> tmp1;
std::optional<d2> tmp2;

// для любых выражений, возвращающих объекты по значению
const base& x = condition ? (const base&)(tmp1 = return_d1_byval()).value()
                          : (const base&)(tmp2 = return_d2_byval()).value() ;

// для конструкторов
const base& x = condition ? (tmp1.emplace(12,34), (const base&)tmp1.value())
                          : (tmp2.emplace("abc"), (const base&)tmp2.value()) ;

template<class T, size_t N>
class optional_array {
  bitset<N> present;

  using memory = aligned_storage<sizeof(T), alignof(T)>::type;
  array<memory, N> data;

  const T& peek(size_t i) const {
    return reinterpret_cast<const T&>(data[i]);
  }
  T& peek(size_t i) {
    return reinterpret_cast<const T&>(data[i]);
  }
public:
  T* get(size_t i) {
    assert(i < N);
    return present[i] ? &peek(i) : nullptr;
  }
  void set(size_t i, const T& v) {  // и то же самое для T&& и для emplace.
    if (present[i])
      peek(i) = v;
    else {
      new(&peek(i)) T(v);
      present[i] = true;
    }
  }
  void reset(size_t i) {
    if (present[i]) {
      peek(i).~T();
      present[i] = false;
    }
  }

  ~optional_array() {
    for(size_t i = 0; i < N; ++i) reset(i);
  }
  optional_array(const optional_array& arr) {  // и то же самое для &&
    for(size_t i = 0; i < N; ++i) if(arr.get(i)) set(arr.get(i));
  }
};

T>>base && x = (true ? static_cast<base&&>(d1()) : static_cast<base&&>(d2()));
T>>x.f() ?
T>>

In general, the lifetime of a temporary cannot be further extended by "passing it on": a second reference, initialized from the reference to which the temporary was bound, does not affect its lifetime.

struct base {
    virtual ~base() {}
    virtual void f() = 0;
};

struct d1 : base { long long x; void f() { x++; } };
struct d2 : base { static int x; void f() { x++; } };

class CBasePlaceholder {
public:
    CBasePlaceholder() : ptr(0) {}
    CBasePlaceholder(const CBasePlaceholder&) = delete;
    CBasePlaceholder(CBasePlaceholder&&) = delete;
    ~CBasePlaceholder() { Destroy(); }

    base* Ptr() const { return ptr; }
    base* operator ->() const { assert(ptr != 0); return ptr; }

    template<typename T> base* New() { Destroy(); return ::new(&bodyStart) T(); }

    void Destroy()
    {
        if (base* toDelete = ptr) {
            ptr = 0;
            toDelete->~base();
        }
    }
private:
    typedef double tAlignmentAs;
    enum {
        firstSize = sizeof(d1),
        secondSize = sizeof(d2),
        bufferSize = firstSize > secondSize ? firstSize : secondSize
    };
    tAlignmentAs bodyStart;
    char bodyRest[bufferSize - sizeof(tAlignmentAs)];
    base* ptr;

};

void foo(bool f)
{
    CBasePlaceholder t;
    base& rt = *(f ? t.New<d1>() : t.New<d2>());
    rt.f();
}

union aligned_storage_t
{
    max_align_t alignment_object;
    unsigned char d1_storage[sizeof(d1)];
    unsigned char d2_storage[sizeof(d2)];
} aligned_storage;

E>Казалось бы, если тяжелы, то стека в два раза меньше съестся...

template<typename T> class AligOf {
    struct S {
        T t;
        char c;
    };
public:
    enum { Value = sizeof( S ) - sizeof( T ) };
};

union aligned_storage_t
NI>{
NI>    max_align_t alignment_object;
NI>    unsigned char d1_storage[sizeof(d1)];
NI>    unsigned char d2_storage[sizeof(d2)];
NI>} aligned_storage;

template<size_t TBufferSize, typename TBase = base, typename TAlligAs = long long >
class CPlaceHolder {
// Всё, как раньше, но добавляем в New проверки

    template<typename T> TBase* New() 
    {
        typedef char assert_corerct_alig[sizeof( TAlligAs ) - AligOf<T>::Value +1];
        typedef char assert_correct_size[TBufferSize - sizeof( T ) + 1];
        Destroy();
        return ptr = ::new( &bodyStart ) T;
    }


};

AlignedCharArrayUnion<d1, d2> d;
const base* pd = true ? (base*) new (d.buffer) d1() : (base*) new (d.buffer) d2();
pd->f();
// ...
pd->~base();

struct base { virtual void f() const = 0;};
struct d1 : base { void f() const {} };
struct d2 : base { void f() const {} };

void f0(const base& d) { d.f(); }
void f1() { d1 d; f0(d); }
void f2() { d2 d; f0(d); }
void (*fn[])()={f1,f2};

void action(int idx) {
  fn[idx&1]();
  if (idx&1) f0(d2()); else f0(d1());
}

E>А если не по-умному, то можно сделать tAlignmentAs параметром шаблона со значением double или там long long по умолчанию

E>Что касается "плясок", то если учесть, что там ещё указатель на виртуальную таблицу должен быть по прихотливой задумке ТС, то получается, что размер остатка буфера не может быть отрицательным, при верном подборе tAlignmentAs, и не может быть равным 0, если в d1 или d2 есть какие-то свои поля.

union
{
    alignment_type<max_value<align_of<d1>::value, align_of<d2>::value>::value>::type alignment_object;
    struct
    {
        unsigned char storage[max_value<sizeof(d1), sizeof(d2)>::value];
        base* ptr;
    } data;
};

E>Динамическая память может быть дорогой по времени...

    struct testAligAs {
        tAligAs a;
        T t;
    };
    typedef char assert_alig_as_size_is_enough[(sizeof(tAligAs)+sizeof(T)-sizeof(testAligAs))*2 + 1];

E>>Динамическая память может быть дорогой по времени...