¿Hay alguna forma estándar de indicar que una función devuelve un nuevo puntero?

A veces quiero delegar la construcción de objetos que posee una clase a una función separada. Algo como

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

donde la función solo está destinada a ser utilizada dentro de una clase que posee el Vertex. Claramente, esta función puede causar cierta confusión de pérdida de memoria, por lo que quiero dejarlo lo más claro posible. ¿Existe una convención de nomenclatura para tales funciones?

Devolver a unique_ptr:

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

Solo puede haber uno que unique_ptrapunte a un objeto determinado (a menos que lo maltrate arrojándolo hacia Vertex*atrás y hacia atrás, de todos modos). Nunca puedes copiar un unique_ptr, solo moverlo. Cuando a unique_ptrse destruye (y no se ha eliminado), incluso deletees el objeto para usted.

make_uniquecrea un nuevo Vertexy lo envuelve en un unique_ptr; los argumentos que pasa make_uniqueson los argumentos que pasa al constructor.

¿Hay alguna forma estándar de indicar que una función devuelve un nuevo puntero?

No, no existe una "forma estándar" (pero hay una política de diseño de API actualmente considerada "mejor práctica").

Debido a esta ambigüedad ("¿qué quiere que haga una función que devuelve un puntero?"), Actualmente se considera la mejor práctica imponer la política de vida y propiedad, a través del tipo de devolución:

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

<vertex pointer type>puede ser std::unique_ptr("new_vertex no posee el puntero"), o std::shared_ptr("el código del cliente no posee el puntero"), o algo más, que tenga una semántica de propiedad claramente definida (por ejemplo, Vertex const * constindicaría al código del cliente "leer el dirección y valores, pero no cambie ninguno / no elimine el puntero ").

En general, no debe devolver un puntero sin formato (pero en algunos casos, "la practicidad es mejor que la pureza").

TLDR : hay una mejor práctica ( sí ), pero no una forma estándar (en el idioma).

Editar :

donde la función solo está destinada a ser utilizada dentro de una clase que posee Vertex

Si la clase posee el Vértice, lo escribiría así:

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

Sí, hay docenas de "estándares" sobre esto

La respuesta recomendada unique_ptres probablemente la mejor respuesta, pero si está buscando punteros en bruto, todos han desarrollado su propio estándar.

En términos generales las funciones nombradas create_____o new______o alloc_____tienden a implicar un nuevo objeto.

sin embargo

Considera que estás mezclando comportamientos. Realmente no le importa si esta es una nueva instancia de un objeto o no. Lo que le importa es si la persona que llama es responsable de destruir el objeto o no. Hay muchas API que transfieren la responsabilidad de un objeto existente, y esas funciones necesitarán un esquema de nomenclatura coincidente. Tal vez give______.

Si está dispuesto a alejarse un poco de C ++ ...
Si está dispuesto a considerar que Objective-C es lo suficientemente similar a C ++ como fuente de respuesta, en realidad hay una respuesta real en ese lenguaje. Objective-C gestiona la vida útil de los objetos utilizando recuentos de referencia. Necesitaban una manera de describir si se le estaba dando la responsabilidad de un objeto, o simplemente una referencia a un objeto existente. Si obtienes la respuesta incorrecta, obtienes los recuentos de referencia incorrectos y pierdes objetos. En consecuencia, establecieron una regla: cada objeto que devuelve es propiedad de otra persona (por lo que debe aumentar y disminuir el recuento de referencia usted mismo), excepto las llamadas de creación que le pasan un puntero ya incrementado (solo tiene que disminuir). Estas llamadas fueron identificadas por el nombre del método. Métodos que comienzan con alloc new copyomutableCopysiempre devuelve un nuevo objeto. Entonces, el estándar hizo cumplir el estándar.