Como alocar para posterior colocação novo "como se por novo"

Não. O melhor que você pode fazer é usar algo como a expressão handle.

O idioma handle é quando você passa um valor que não é um ponteiro real para seus dados reais. Você pode permitir que ele seja deletado fazendo com que o handle tenha um destrutor que você controla.

struct Interface {
  virtual void DoStuff() const = 0;
  virtual ~Interface() {}
};

struct Forwarder:Interface {
  virtual void DoStuff() const { return pImpl->DoStuff(); }
  Interface* pImpl = 0;
  ~Forwarder() {
    /* delete pImpl using your internal mechanism */
  }
};

então retorne new Forwarder{ pRealObject }de suas APIs.

Eles são deleteo Forwarderobjeto, que faz a limpeza adequada no seu objeto subjacente real pImpl. Se ele tiver uma tabela de função virtual, sua Forwarderimplementação apenas salta tudo para mexer com pImplisso.

E se não houver uma tabela de funções virtuais (por exemplo, funções livres em um ADT), você ensina esses ADTs a converter os argumentos para Forwarder*então usá pImpl-los.

Pode ajudar se você usar uma classe diferente para o público Interfacedo que sua interna pImplpara evitar chamar APIs públicas que esperam identificadores com o tipo interno e vice-versa; isso requer alguma duplicação de código ou alguma tolice de modelo.

Em um ambiente mais parecido com C, o idioma do identificador se parece com:

struct Handle;
typedef Handle* HANDLE;
HANDLE Create();
/* internally */
struct Handle { void* pImpl; };

onde você retorna um ponteiro para uma estrutura opaca do seu código de criação.

Resposta curta: Não.

Resposta longa:

Quais ponteiros são operandos válidos para expressões de exclusão de objeto único (por exemplo, delete ptr;) são abordados no padrão por expr.delete:

7.6.2.9 Expressões unárias - Excluir [expr.delete]

⁽²⁾ [...] Em uma expressão delete de objeto único, o valor do operando de delete pode ser um valor de ponteiro nulo, um ponteiro para um objeto não array criado por uma new-expression anterior , ou um ponteiro para um subobjeto representando uma classe base de tal objeto. Se não, o comportamento é undefined . [...]

[ênfase minha]

Então, se você quer delete ptr;ser definido, precisa ser:

• um ponteiro nulo
• um ponteiro retornado por uma nova expressão (por exemplo T* ptr = new T;)
  (ou no caso Tde ser do tipo classe, então um ponteiro para uma das Tclasses base de também é permitido)

Observe que isso descarta imediatamente qualquer trapaça como chamar operator newmanualmente e depois usar placement-new para criar um objeto nessa memória.

• O ponteiro usado como operando para a expressão de exclusão deve ser criado por uma nova expressão.
• O tipo do ponteiro passado para a expressão de exclusão deve corresponder ao tipo do objeto alocado pela nova expressão (ou, para classes, também pode ser um ponteiro para a classe base).

Existem algumas alternativas que você pode considerar:

1. Use um alocador

Os alocadores dividem a alocação e a construção em etapas separadas (e destruição e desalocação).

Então, supondo que você possa alterar seu código para usar std::allocator(ou qualquer outro alocador que satisfaça os requisitos de completude do alocador ), seria possível alocar T's sem inicializá-los:

template<class T>
void example() {
    using alloc_traits = std::allocator_traits<std::allocator<T>>;
    std::allocator<T> alloc;

    T* ptr = alloc_traits::allocate(alloc, 1);
    // ptr is uninitialized
    
    // ...

    // construct a T at ptr
    alloc_traits::construct(alloc, ptr /* , ...constructor args */);

    // ...

    // "delete ptr;" replacement:
    alloc_traits::destroy(alloc, ptr);
    alloc_traits::deallocate(alloc, ptr, 1);
}

ou dado que você marcou sua pergunta com unique-ptr :

template<class T>
struct std_allocator_deleter {
    constexpr void operator()(T* ptr) const {
        using alloc_traits = std::allocator_traits<std::allocator<T>>;
        std::allocator<T> alloc;

        alloc_traits::destroy(alloc, ptr);
        alloc_traits::deallocate(alloc, ptr, 1);
    }
};

template<class T>
std::unique_ptr<T, std_allocator_deleter<T>> allocate_unique() {
    using alloc_traits = std::allocator_traits<std::allocator<T>>;
    std::allocator<T> alloc;

    T* ptr = alloc_traits::allocate(alloc, 1);
    return std::unique_ptr<T, std_allocator_deleter<T>>(ptr);
}


template<class T>
void example() {
    // allocate uninitialized storage
    auto ptr = allocate_unique<T>();
    // ...
    // construct a T 
    new(ptr.get()) T();
    // ...
    // ptr destructor automatically destroys & deallocates T
}

Observe que você deve garantir que sempre crie um novo Tobjeto nesse armazenamento, caso contrário, o std_allocator_deleterdeleter terá um comportamento indefinido.

2. Não use uma expressão de exclusão

Uma solução simples seria simplesmente não usar uma expressão de exclusão.
Se você chamar explicitamente o destrutor seguido por uma chamada para operator deleteseu programa também seria bem comportado:

T* ptr = (T*)::operator new(sizeof(T));
// ...
new(ptr) T();
// ...



// undefined behavior:
// delete ptr;

// OK:
ptr->~T();
::operator delete(ptr);

3. Crie um objeto com uma nova expressão e substitua-o

Se seus Ttipos forem construtíveis por padrão de forma barata (ou você puder modificá-los para que sejam), você pode simplesmente usar uma new-expression normal e chamar seu destrutor imediatamente:

template<class T>
T* allocate_uninitialized() {
    T* ptr = new T;
    ptr->~T();
    return ptr;
}

template<class T>
void example() {
    T* ptr = allocate_unitialized<T>();
    // ...
    new (ptr) T();
    // ...
    delete ptr;
}

Observe que você deve sempre colocar um novo Tobjeto no ponteiro retornado por allocate_uninitialized()antes de passá-lo para uma expressão de exclusão, caso contrário, o comportamento será indefinido.