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