Base t(std::move(b));
Derived* d = new(&b)Derived(std::move(t));

base = turn_A_to<B>(base);

#include <iostream>

struct A {
    virtual void func (void) {std::cout << "A\n";};
};

struct B : A {
    virtual void func (void) {std::cout << "B\n";}
};

static int
bar (B *b)
{
  b->func(); //this will be inlined in optimized builds.
}

int
main (void)
{
  B b;
  bar (&b);
  return 0;
}

main:
subq $24, %rsp
movq %rsp, %rdi
movq $_ZTV1B+16, (%rsp)
call _ZN1B4funcEv
... etc

_ZN1B4funcEv:
movl $2, %edx
movl $.LC0, %esi
movl $_ZSt4cout, %edi
jmp _ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l
... etc

.LC0:
.string "B\n"

int
main (void)
{
  B b;
  bar (&b);
  ::new (&b) A;
  bar (&b);
  return 0;
}

Мне нужно решить на самом деле обратную задачу
Вызвать placement new без вызова конструктора.

Для классов с виртуальными функциями new(oldobj) просто меняет (инициализирует)
vtbl. А конструктор инициализирует поля. Мне надо вызвать new(place) но не конструктор.

#include <cstdio>
#include <memory>

struct Base
{
    virtual const char* whoami() const { return "Base"; }
};

struct Derived : Base
{
    Derived(Base&& b) : Base(b) {}
    virtual const char* whoami() const { return "Derived"; }
};

void patch(Base* b)
{
    Base t(std::move(*b));
    Derived* d = new(b)Derived(std::move(t));    
}

int main()
{
    Base ob;
    Base* pb = &ob;
    patch(pb);
    printf("%s %s\n", ob.whoami(), pb->whoami()); // -O2: Base Base | -O0: Base Derived
};

К>#include <cstdio>
К>#include <memory>

К>struct Base
К>{
К>    virtual const char* whoami() const { return "Base"; }
К>};

К>struct Derived : Base
К>{
К>    Derived(Base&& b) : Base(b) {}
К>    virtual const char* whoami() const { return "Derived"; }
К>};

К>void patch(Base* b)
К>{
К>    Base t(std::move(*b));
К>    Derived* d = new(b)Derived(std::move(t));    
К>}

К>int main()
К>{
К>    Base ob;
К>    Base* pb = &ob;
К>    patch(pb);
К>    printf("%s %s\n", ob.whoami(), pb->whoami()); // -O2: Base Base | -O0: Base Derived
К>};
К>

int main()
{
    void *pmem = nullptr;
    Base *pb = nullptr;
    
    Derived o1;
    pmem = &o1;
    pb = new(pmem)Base;
    printf("%s\n", pb->whoami()); // ok: -O2: Base | -O0: Base
    
    Base o2;
    pmem = &o2;
    pb = new(pmem)Derived;
    printf("%s\n", pb->whoami()); // failed: -O2: Base | -O0: Derived
}

    Base *pb = new Base;
    pb = new(pb)Derived;
    printf("%s\n", pb->whoami()); // ok: -O2: Derived| -O0: Derived

int main()
{
    Derived o1;
    Base* pbb = new(&o1)Base();
    Base* pb1 = &o1;
    printf("\n");
    printf("%s\n", pb1->whoami()); // Base
    printf("%s\n", pbb->whoami()); // Base
    
    Base o2;
    Derived* pbd = new(&o2)Derived();
    Derived* pb2 = (Derived*)&o2;
    printf("\n");
    printf("%s\n", pb2->whoami()); // Base
    printf("%s\n", pbd->whoami()); // Base

    Base* o3 = &o1;
    Derived* pbm = new(o3)Derived();
    Base* pb3 = (Base*)o3;
    printf("\n");
    printf("%s\n", pb3->whoami()); // Derived
    printf("%s\n", pbm->whoami()); // Derived

    Base* o4 = &o2;
    Derived* pbn = new(o4)Derived();
    Base* pb4 = (Base*)o4;
    printf("\n");
    printf("%s\n", pb4->whoami()); // Base
    printf("%s\n", pbn->whoami()); // Base

    Base o5[1]; // или любое другое хранилище, например, intptr_t[12345]
    Derived* pbz = new(o5)Derived();
    Base* pb5 = (Base*)o5;
    printf("\n");
    printf("%s\n", pb5->whoami()); // Derived
    printf("%s\n", pbz->whoami()); // Derived
};