A program may end the lifetime of an object of class type without invoking the destructor, by reusing or releasing the storage as described above.

In this case, the destructor is not implicitly invoked and any program that depends on the side effects produced by the destructor has undefined behavior.

#include <concepts>
#include <type_traits>
#include <algorithm>

template <typename T, typename ... U>
concept c_any_of = ( std::same_as<T, U> || ... );

template <typename T_base, std::derived_from<T_base> ... T_sub>
struct keep {
  static constexpr std::size_t
  s_max_size = std::max<std::size_t>({sizeof(T_base), sizeof(T_sub) ...});
  
  static constexpr std::size_t
  s_max_align = std::max<std::size_t>({alignof(T_base), alignof(T_sub) ...});
  
  static constexpr bool
  s_all_trivial_des = (
    std::is_trivially_destructible_v<T_base> &&
    (std::is_trivially_destructible_v<T_sub> && ...)
  );
  
  using t_data = std::aligned_storage_t<s_max_size, s_max_align>;
  using pointer = T_base *;
  
  private:
  t_data m_data;
  public:
  pointer m_base = nullptr;
  
  ~keep() requires(! s_all_trivial_des) {
    clear();
  }

  template <c_any_of<T_base, T_sub ...> T, typename ... T_args>
  T * emplace(T_args && ... p_args) {
    clear();
    T * ret = new (&m_data) T(std::forward<T_args>(p_args) ...); 
    m_base = ret;
    return ret;
  }
  
  operator bool () const {
    return m_base != nullptr;
  }

  pointer operator -> () {
    return m_base;
  }

  void clear() {
    if( m_base != nullptr ) {
      if constexpr( ! s_all_trivial_des ) { m_base->~T_base(); }
      m_base = nullptr;
    }
  }
};

#include <memory>

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
class A
{
public:
    int v1;
    int v2;

    virtual ~A(){}
};

class B: public A
{
public:
    int v3;
    B(A a)
        : A{std::move(a)}
        , v3{1}
    {}
};

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
union Space
{
    char stub;
    A a;
    B b;
    Space() : stub{} {}
    ~Space() {}
} space{};

//ну, это и так понятно
static_assert(static_cast<void*>(&space.a) == static_cast<void*>(&space.b));

//важный инвариант: самостоятельная часть A и под-часть A из B - лежат в одном и том же месте
static_assert(&space.a == static_cast<A*>(&space.b));


/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
A* storedPa{};
void store(A* pa)
{
    storedPa = pa;
}

void useStoredPointer()
{
    storedPa->v1 = 220;
    int k = storedPa->v2;
}

/////////0/////////1/////////2/////////3/////////4/////////5/////////6/////////7
int main()
{
    //создаем общий функционал A
    new(&space.a) A;

    store(&space.a);
    useStoredPointer();

    //немного с ним поработали, поняли что его надо заменить на уточненный функционал B
    {
        //запомним общее состояние
        A aState = std::move(space.a);
        //разрушим общий оригинал
        space.a.~A();
        //пересоздадим его как уточненный, заодно зарядим его прошлым состоянием
        new(&space.b) B{std::move(aState)};
    }

    //теперь работаем с B
    //причем так что его общая под-часть A имеет такой же адрес как и раньше до B
    useStoredPointer();

    //поработали, заканчиваем время жизни B
    space.b.~B();

    return 0;
}

std::variant<ClientCommon, Client1, Client2> v;
v = ClientCommon{};
v = Client1{std::move(std::get<ClientCommon>(v))};

class ClientCommon {...};
class Client1 { ClientCommon  common; ...};
class Client2 { ClientCommon  common; ...};

ClientCommon cc;
foo(cc);
if (condition) {
  Client1 cl1;
  cl1.common = std::move(cc);
  ...
} else {
  Client2 cl2;
  cl2.common = std::move(cc);
  ...
}

SP>>std::variant<ClientCommon, Client1, Client2> v;
SP>>v = ClientCommon{};
SP>>v = Client1{std::move(std::get<ClientCommon>(v))};
SP>>

struct ClientCommon;

struct ClientImpl { ClientCommon * m_outer; };
struct Client1 : ClientImpl {};
struct Client2 : ClientImpl {};

struct ClientCommon {
  // общие данные
  
  // реализация
  keep<ClientImpl, Client1, Client2> m_impl;
};