class Object {
 public:
  virtual ~Object() = 0;
};

inline Object::~Object() {}

class HeapInterface {
 public:
  virtual void * Allocate(size_t number_bytes) = 0;
  virtual void   Deallocate (void * ptr) = 0;
  virtual ~HeapInterface() {}
};

class Ansector1 : public Object {
 public:
  virtual ~Ansector1() {}
  void* operator new (std::size_t size) {assert(0);return 0;}
  void* operator new (std::size_t size, HeapInterface * context) {
    const size_t kPtrSize = sizeof (HeapInterface*);
    void * block = context -> Allocate(size+kPtrSize);
    Ansector1 * ret = reinterpret_cast<Ansector1*>(static_cast<char *>(block) + kPtrSize);
    HeapInterface ** heap_ptr = static_cast<HeapInterface **>(block);
    heap_ptr[0] = context;
    return ret;
  }
  void operator delete (void* ptr) {
    HeapInterface * heap_value = static_cast<HeapInterface**>(ptr)[-1];
    heap_value->Deallocate(static_cast<HeapInterface**>(ptr)-1);
  }
  HeapInterface * heap() {return reinterpret_cast<HeapInterface **>(this)[-1];}
  void set_heap (HeapInterface * value) {reinterpret_cast<HeapInterface **>(this)[-1] = value;}

  /*
   * Недостатки:
   *  1) нельзя использовать со стандартными контейнерами
   *  2) непрозрачность извне (напишет кто-то перебор массива таких элементов с помощью указателей... и никогда не поймёт, где ошибка)
   *  3) нерабочая арифметика указателей
   */
};

class Ansector2 : public Object {
 public:
  Ansector2(HeapInterface * context_value) : heap_(context_value) {}
  virtual ~Ansector2() {}
  void operator delete (void* ptr) {
    HeapInterface * heap_value = static_cast<Ansector2*>(ptr)->heap(); // грязный хак - обращение к члену класса после вызова деструктора класса
    heap_value->Deallocate(ptr);
  }
  HeapInterface * heap() {return heap_;}
  void set_heap (HeapInterface * value) {heap_ = value;}

 private:
  HeapInterface * heap_;

  /*
   * Недостатки:
   *  1) использование грязного хака
   */
};

class Object3 {
  public:
  virtual void SelfDestruct() = 0;
   virtual ~Object3() = 0;
};
inline Object3::~Object3() {}

class Ansector3 : public Object3 {
 public:
  Ansector3(HeapInterface * context_value) : heap_(context_value) {}
  HeapInterface * heap() {return heap_;}
  void set_heap (HeapInterface * value) {heap_ = value;}
  virtual void SelfDestruct() {SelfDestruct(this);}

 protected:
  void operator delete (void* ptr) {} //ничего не делает. защищён, чтобы нельзя напрямую было вызывать Ansector3::new и Ansector3::delete
  static Ansector3 * Create() {/* некий кодД */} //new использовать невозможно, но можно сделать фабричный метод (дофантазируйте его определение сами)

 private:
  static void SelfDestruct(Ansector3 * self) {
    HeapInterface * heap_value = self->heap();
    self->~Object3();
    heap_value->Deallocate(self);
  }
  HeapInterface * heap_;
/*
 * Недостатки:
 * 1)удаление только через функцию
 * 2)невозможность использовать некоторые стандартные фишки - например, стандартные умные указатели из разных библиотек, придётся писать свои
 */
};

class XxxInterface : public Object{};

class Xxx : public XxxInterface {};

/*
...
некий код
*/

XxxInterface * p = Xxx::Create();
/*
...
некий код
*/

delete p; //или p->SelfDestruct(); в одной из архитектур

E>>Как это что? Её затрут указателем на таблицу предка жешь...

struct B { virtual void foo( int );}
struct D : B { 
    int z;
    void foo( int x ) { z = x; } 
};

void bar()
{
    D d;
    // Тут, когда будет работать деструктор B, как думаешь, какая версия foo вызовется и почему?..
}

class __declspec(novtable) Object 
{
public:
    virtual ~Object()
    {

    }
    virtual void Delete() = 0;
};

class Ansector1 : public Object 
{
    void Delete()
    {
        delete this;
    }

public:
    virtual ~Ansector1() {}
    
    void* operator new (size_t size) 
    {
        return LocalAlloc(0, size);//например
    }
    
    void operator delete (void* p) 
    {
        LocalFree(p);//например
    }
};

.....
    if (Object* po = new Ansector1)
    {
        po->Delete();// вызывается Ansector1::operator delete
    }

struct IHeap {
    virtual void* Alloc( size_t ) = 0;
    virtual void Free( void* ) = 0;

    // Нулевой аллокатор трактуем, как дефолтный.
    static void* AllocAt( size_t size, IHeap* at = 0 ) 
        { return at ? at->Alloc( size ) : ::operator new( size ); }
    static void FreeAt( void* block, IHeap* at = 0 )
    {
        if( at )
            at->Free( block );
        else
            ::operator delete( block );
    }
};

struct AllocateOnHeap {
    void* operator new( size_t size, IHeap* heap = 0 )
    {
        IHeap** res = (IHeap**) IHeap::AllocAt( size + sizeof( IHeap* ), heap );
        if( res )
            *res++ = heap;
        return res;
    }
    void operator delete( void* block, IHeap* heap ) 
    { 
        if( block )
            IHeap::FreeAt( -1 + (IHeap**)block, heap ); 
    }
    void operator delete( void* block )
    { 
        if( block )
            operator delete( block, -1[(IHeap**)block] ); 
    }

    void* operator new[]( size_t size, IHeap* heap = 0 ) 
        { return operator new( size, heap ); }
    void operator delete[]( void* block, IHeap* heap ) 
        { operator delete( block, heap ); }
    void operator delete[]( void* block ) 
        { operator delete( block ); }
};

class MyClass : public AllocateOnHeap {
};

delete new( getMyHeap() ) MyClass;

M>>Я рассказал довольно много с помощью кода

К>Знаешь про отмазку TL;DR? Знаешь, что первые две буквы в ней означают?

void * НеведомыйМетодСозданияОбъектаСПомощьюВнешнегоАллокатораИ100500Прибамбас(HeapСтранныйКласс & heap,...)
void НеведомыйМетодУдаленияОбъектаСПомощьюВнешнегоАллокатораИ100500Прибамбас(void * ptr, HeapСтранныйКласс & heap,...)

ATOMIC{ myQueue.push(x) }
atomic(myQueue).push(x);

myQueue.atomic_push(x);

M>Кодт, если у тебя есть предложения по более грамотной архитектуре, это круто, буду рад

К>myQueue.atomic_push(x);
К>

myQueue.push_back(x)

К>>myQueue.atomic_push(x);
К>>

M>myQueue.push_back(x)
M>

myQueue.lock(); // todo использовать scoped lock
myQueue.push_back(x);
myQueue.push_back(y);
.....
myQueue.unlock();

// или так
auto lockedQueue = myQueue.locked();
lockedQueue.push_back(x);
lockedQueue.push_back(y);
.....

E>    void operator delete( void* block )
E>    { 
E>        if( block )
E>            operator delete( block, -1[(IHeap**)block] ); 
E>    }