How to restrict an object being allocated on the heap?

One way can be declaring a

private:
  operator new(size_t);

in the class. No implementation is needed.

Simply an expression like new yourclass dosn't compile since a class new operator is declared but cannot be called, being private.

This is similar as declaring copy and assign as private to disable copy and assignment capabilities produced by default.

This combination:

template <typename T>
class OnStackType
{
  T m_value;

public:
  OnStackType()                   { m_value = T(); };
  OnStackType(const T& init)  { m_value = init; };
  
  operator T&()               { return m_value; };
  T* operator &()             { return &m_value; };
  T& GetValue()               { return m_value; };
};

class A
{
  int m_iMember;

protected:
  A() : m_iMember(0) {};
  A(const A& a) : m_iMember(a.m_iMember) {};
  ~A() {};

public:
  void SetMember(int iSet) { m_iMember = iSet; };

  friend class OnStackType<A>;
};

- will allow the code: OnStacType<A> a; ,
not: A a; ,
but: OnStackType<A>* pa = new OnStackType<A>(); ... :)

There's rarely a good reason to do this. So perhaps you need to reconsider your design/requirements.