void *pmem = ...;
Thing* pt = new(pmem) Thing(params);

((ololo*)p)->ololo::ololo();

CS>Мне нужно решить на самом деле обратную задачу

struct Thing
{
  struct ThingImpl;
  typedef std::unique_ptr<ThingImpl> Pimpl;

  Thing(Pimpl p) : pimpl_(p) {}
  // другие нормальные инициализирующие pimpl_ конструкторы

  virtual ~Thing() {} // pimpl_ будет прибит тут автоматом

  template<class T>
  T* mutate() {
    Pimpl tmp( pimpl_ ); // теперь this своим pimpl-ом не владеет
    ~Thing(); // естественно, деструктор должен быть виртуальным
    return new(this) T(tmp);
  }

protected: // наследникам нужен доступ к потрохам
  Pimpl pimpl_;
};

struct data {};

struct test {

   optional< data > m_data;

   test ( NO_INIT ) { m_data.is_valid = true; }

};

CS>>Мне нужно решить на самом деле обратную задачу

J>placement new без вызова конструктора называется reinterpret_cast

union {
  Thing t1;
  OtherThing t2;
}

J>>placement new без вызова конструктора называется reinterpret_cast

CS>union {
CS>  Thing t1;
CS>  OtherThing t2;
CS>} 
CS>

4 [ Note: In general, one must use explicit destructor calls and placement new operators to change the active
member of a union. —end note ] [ Example: Consider an object u of a union type U having non-static data
members m of type M and n of type N. If M has a non-trivial destructor and N has a non-trivial constructor
(for instance, if they declare or inherit virtual functions), the active member of u can be safely switched
from m to n using the destructor and placement new operator as follows:

u.m.~M();
new (&u.n) N;

—end example ]

CS>Мне нужно решить на самом деле обратную задачу

struct Data
{
    int a;
};

struct Storage
{
    // здесь, возможно, будет лучше использовать aligned_storage для Data и Thing/OtherThing/YetAnotherThing.
    Data data;
    Thing thing;
};

class Thing
{
    ...
    Data *data()
    {
        return ((char *)this) + offset;
    }
    ...

    virtual int value() { return data()->a; }
};

#include <iostream>
#include <string>
#include "boost/aligned_storage.hpp"

using namespace std;

struct NO_INIT {};

struct ThingData {
    int a;
    string s;
    ThingData(int v): a (v), s("test") { std::cout << "create ThingData\n"; }
    ~ThingData() { std::cout << "destroy ThingData\n"; }
};

class Thing {
    typedef ThingData data_type;
    typedef boost::aligned_storage<sizeof(data_type),
            boost::alignment_of<data_type>::value>::type storage_type;
    storage_type storage;

protected:
    Thing(NO_INIT) {}
    data_type* get_data() {return reinterpret_cast<data_type*>(&storage);}
    const data_type* get_data() const {return reinterpret_cast<const data_type*>(&storage);}

public:
    Thing(int v = 0) { new (&storage) data_type(v); }
    virtual ~Thing() { (*get_data()).~data_type(); }

    virtual const char * type_name(){ return "Thing"; }
    virtual int value() const { return get_data()->a; }
    virtual string str() const { return get_data()->s; }
};

struct Operand;

// ООП (паттерн Стратегия)
struct IOperator
{
  virtual void doit(Operand& operand) const = 0;
  virtual const char* whoami() const = 0;
};

// Си или ФП
struct OperatorVTBL
{
  void (*doit)(Operand& operand);
  const char* (*whoami)();
  const char* itsme;
};

struct Operand
{
  int f1, f2;
  IOperator* op; // так
  OperatorVTBL* vp; // этак

  void doit() { op->doit(*this);  }
  const char* whoami() const { return op->whoami(); }
};

struct Summator : IOperator
{
  void doit(Operand& operand) { operand.f1 += operand.f2; }
  const char* whoami() const { return "+"; }
} summator_v1;

OperatorVTBL summator_v2 = {
  [](Operator& operand)->void { operand.f1 += operand.f2; },
  []()->const char* { return "+"; },
  "+",
};

#include <cstdio>
#include <memory>

struct Base
{
    int x, y, z;
    Base(int i) : x(i), y(i+i), z(i*i) {}
    virtual void whoami() { printf("%p base %d %d %d\n", this, x, y, z); }
};

struct Derived : Base
{
    Derived(Base&& b) : Base(b) {}
    virtual void whoami() { printf("%p derived %d %d %d\n", this, x, y, z); }
};

int main()
{
    Base b(3);
    Base* p = &b;

    b.whoami();   // 000000000022fd50 base 3 6 9
    p->whoami();  // 000000000022fd50 base 3 6 9

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

    printf("-----\n");
    b.whoami();   // 000000000022fd50 base 3 6 9
    p->whoami();  // 000000000022fd50 derived 3 6 9
    d->whoami();  // 000000000022fd50 derived 3 6 9
};

struct ThingData
{
    int f1;
    int f2;
};

struct Summator
{
    void doAction1(ThingData &self)  { self.f1 += self.f2; }
    const char* type_name() { return "Summator"; }
};

struct Substractor
{
    void doAction1(ThingData &self)  { self.f1 -= self.f2; }
    const char* type_name() { return "Substractor"; }
};

using Thing = SubVariant<ThingData, Summator, Substractor>;

int main()
{
    auto test = [](auto &self, auto &sub)
    {
        sub.doAction1(self);
        cout << sub.type_name() << " " << self.f1 << " " << self.f2 << endl;
    };

    Thing x = {{5, 7}, Summator{}};
    apply(test, x);
    x.sub = Substractor{};
    apply(test, x);

    cout << "size: " << sizeof(x.sub) << endl;
}

Summator 12 7
Substractor 5 7
size: 2

#define BOOST_VARIANT_MINIMIZE_SIZE

#include <boost/variant.hpp>
#include <type_traits>
#include <functional>
#include <iostream>
#include <utility>

using namespace std;

/****************************************************************/
// Boost.Variant requires result_type:
template<typename T, typename F>
struct ResultType
{
     mutable F f;
     using result_type = T;

     template<typename ...Args> T operator()(Args&& ...args) const
     {
         return f(forward<Args>(args)...);
     }
};

template<typename T, typename F>
auto make_result_type(F &&f)
{
    return ResultType<T, typename decay<F>::type>{forward<F>(f)};
}
/****************************************************************/
// Proof-of-Concept
template<typename Base, typename ...Ts>
struct SubVariant
{
    Base shared_data;
    boost::variant<Ts...> sub;

    template<typename Visitor>
    friend auto apply(Visitor visitor, SubVariant &operand)
    {
        using result_type = typename common_type
        <
            decltype( visitor(shared_data, declval<Ts&>()) )...
        >::type;

        return boost::apply_visitor(make_result_type<result_type>([&](auto &x)
        {
            return visitor(operand.shared_data, x);
        }), operand.sub);
    }
};
/****************************************************************/
// Demo:

struct ThingData
{
    int f1;
    int f2;
};

struct Summator
{
    void doAction1(ThingData &self)  { self.f1 += self.f2; }
    const char* type_name() { return "Summator"; }
};

struct Substractor
{
    void doAction1(ThingData &self)  { self.f1 -= self.f2; }
    const char* type_name() { return "Substractor"; }
};

using Thing = SubVariant<ThingData, Summator, Substractor>;

int main()
{
    auto test = [](auto &self, auto &sub)
    {
        sub.doAction1(self);
        cout << sub.type_name() << " " << self.f1 << " " << self.f2 << endl;
    };
    
    Thing x = {{5, 7}, Summator{}};
    apply(test, x);
    x.sub = Substractor{};
    apply(test, x);

    cout << "size: " << sizeof(x.sub) << endl;
}

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
};

If a program ends the lifetime of an object of type T with static (3.7.1), thread (3.7.2), or automatic (3.7.3)
storage duration and if T has a non-trivial destructor,39 the program must ensure that an object of the
original type occupies that same storage location when the implicit destructor call takes place; otherwise the
behavior of the program is undefined. This is true even if the block is exited with an exception. [ Example:

class T { };
struct B {
    ~B();
};

void h() {
    B b;
    new (&b) T;
} // undefined behavior at block exit

—end example ]

To AntonTykhyy: consider tree of HTML DOM elements (class element). After parsing and later in runtime each DOM element may get different layout models defined by CSS/styles, script, etc. So each element is allowed to be of class block_element, table_element, etc — with different layout and visibility rules. Having such dynamic subclassing is essential to architecture that I use in my Sciter engine : terrainformatica.com/sciter – c-smile 17 hours ago

To c-smile: Then change the architecture. If you want to change elements' behavior at runtime, separate behavior from data and assign pointers to behavior objects. The only thing you are saving using this sort of undefined behavior is one pointer access, and one very likely to hit the cache, at that. – Anton Tykhyy 17 hours ago

To AntonTykhyy: Additional level of indirection is one drawback, another one is that use of strategy or pimpl pattern increases maintenance/development cost. Root class has around 50 methods that need to be bridged to current strategy methods. Not that pretty at the end. And it's not clear why to introduce new entities if C++ already has builtin infrastructure. Virtuality is a strategy implementation if to think slightly out of the box. c-smile 16 hours ago

// boost::variant
apply([](auto &self, auto &sub) // single dispatch per batch
{
    for(int i=0; i!=1000000; ++i)
    {
        sub.doAction1(self); // no dispatch, inlining
        sub.doAction2(self); // no dispatch, inlining
        // ...
    }
}, x);
// versus vtbl
for(int i=0; i!=1000000; ++i)
{
    x->doAction1(); // virtual call (PGO?)
    x->doAction2(); // virtual call (PGO?)
    // ...
}

#include <iostream>
#include <string>
#include <memory>

struct I
{
    virtual const char* who() const = 0;
};

struct D
{
    int x;
    std::string y;
    D(int x, std::string y) : x(x), y(y) {}
    D(D&& d) : x(std::move(d.x)), y(std::move(d.y)) {}
};

struct A: I
{
    std::unique_ptr< D > data;

    template <typename ...T>
    A(T &&...t) : data(new D(std::forward<T>(t)...)) {}
    A(A &a) { data.swap(a.data); }
    A(A &&a) : data(std::move(a.data)) {}

    const char* who() const { return "A"; }
};

struct B : A
{
    B(A &a) : A(a) {}
    B(A &&a) : A(std::move(a)) {}
    const char* who() const { return "B"; }
};

struct F: I
{
    std::unique_ptr< A >  impl;

    template < typename T >
    F(T &&t) : impl(new T(std::move(t))) {}
    ~F() { }

    const char* who() const { return impl->who(); }

    void show() const { std::cout << (void const*)impl.get() << " " << who() << " " << impl->data->x << " [" <<  impl->data->y << "]" << std::endl; }

    template < typename T>
    void turn_to()
    {
        std::unique_ptr< A > nimpl(new T(*impl.get()));
        impl.swap(nimpl);
    }
};

int main()
{
    std::unique_ptr< F > pa(new F(A(123, "text")));
    pa->show();
    pa->turn_to<B>();
    pa->show();
}

struct vobject 
{
  vtbl* methods;
  ... data ...
}