Existe uma maneira padrão de indicar que uma função retorna um novo ponteiro?

Às vezes, quero delegar a construção de objetos que uma classe possui para uma função separada. Algo como

Vertex* new_vertex(const Options& options) {
  // do stuff...
  return new Vertex(...);
}

onde a função se destina apenas a ser usada dentro de uma classe que possui o Vertex. Claramente, essa função pode causar alguma confusão de vazamento de memória, por isso quero deixar o mais claro possível. Existe uma convenção de nomenclatura para essas funções?

Retornar a unique_ptr:

std::unique_ptr<Vertex> new_vertex(const Options& options) {
  // do stuff...
  return std::make_unique<Vertex>(...);
}

Só pode haver um que unique_ptraponte para um determinado objeto (a menos que você o abuse ao transmitir para um Vertex*e para trás, de qualquer maneira). Você nunca pode copiar um unique_ptr, apenas movê-lo. Quando um unique_ptré destruído (e não foi removido), ele deleteé o objeto para você.

make_uniquecria um novo Vertexe envolve-o em um unique_ptr; os argumentos aos quais você passa make_uniquesão os argumentos que passa para o construtor.

Existe uma maneira padrão de indicar que uma função retorna um novo ponteiro?

Não, não existe uma "maneira padrão" (mas há uma política de design de API atualmente considerada "prática recomendada").

Devido a essa ambiguidade ("o que uma função que retorna um ponteiro quer que eu faça com ela?"), Atualmente é considerado uma boa prática impor a política de duração e propriedade, por meio do tipo de retorno:

<vertex pointer type> new_vertex(const Options& options);

<vertex pointer type>pode ser std::unique_ptr("new_vertex não possui o ponteiro") ou std::shared_ptr("o código do cliente não possui o ponteiro") ou qualquer outra coisa que tenha definido claramente a semântica de propriedade (por exemplo, Vertex const * constindicaria para o código do cliente "leia o endereço e valores, mas não altere nem exclua o ponteiro ").

Geralmente, você não deve retornar um ponteiro bruto (mas, em alguns casos, "a praticidade supera a pureza").

TLDR : existe uma prática recomendada ( sim ), mas não uma maneira padrão (no idioma).

Editar :

onde a função se destina apenas a ser usada dentro de uma classe que possui o Vertex

Se a classe possuir o Vertex, eu escreveria assim:

class SomeClass // owns the vertex
{
    void do_stuff() // uses the vertex internally
    {
        init_vertex(); // see below
        assert(vertex.get());
        // use vertex as needed
    }
private:
    // "class owns the Vertex"
    std::unique_ptr<Vertex> vertex;

    // sets the internal vertex
    // function doesn't return a pointer of any kind
    void init_vertex(const Options& options); // or "reset_", "refresh_", 
                                              // or "make_" vertex,
                                              // if the pointer can change
                                              // throughout the lifetime
                                              // of a SomeClass instance
};

Sim, existem dezenas de "padrões" sobre isso

A resposta que recomenda unique_ptré provavelmente a melhor resposta, mas se você estiver olhando para indicadores brutos, todos desenvolveram seu próprio padrão.

De um modo geral funções de chamada create_____ou new______ou alloc_____tendem a implicar um novo objeto.

Contudo

Considere que você está misturando comportamentos. Você realmente não se importa se essa é uma nova instância de um objeto ou não. O que importa é se o chamador é responsável por destruir o objeto ou não. Existem muitas APIs que assumem a responsabilidade por um objeto existente e essas funções precisarão de um esquema de nomenclatura correspondente. Talvez give______.

Se você deseja se afastar um pouco do C ++ ...
Se você deseja considerar o Objective-C como semelhante ao C ++ como fonte de resposta, na verdade há uma resposta real nessa linguagem. Objective-C gerencia a vida útil dos objetos usando contagens de referência. Eles precisavam de uma maneira de descrever se você estava sendo responsabilizado por um objeto ou apenas uma referência a um objeto existente. Se você errar a resposta, errará as contagens de referências e perderá objetos. Dessa forma, eles estabeleceram uma regra: todo objeto retornado pertence a outra pessoa (portanto, você deve aumentar e diminuir a contagem de referências), exceto as chamadas de criação que passam um ponteiro já incrementado para você (você só precisa diminuir). Essas chamadas foram identificadas pelo nome do método. Métodos começando com alloc new copyoumutableCopysempre retornava um novo objeto. Então, o padrão foi imposto pelo idioma.