Gibt es eine Standardmethode, um anzuzeigen, dass eine Funktion einen neuen Zeiger zurückgibt?

Manchmal möchte ich die Konstruktion von Objekten, die eine Klasse besitzt, an eine separate Funktion delegieren. Etwas wie

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

wobei die Funktion nur innerhalb einer Klasse verwendet werden soll, die die besitzt Vertex. Es ist klar, dass diese Funktion zu Verwirrung führen kann, daher möchte ich sie so klar wie möglich machen. Gibt es eine Namenskonvention für solche Funktionen?

Rückgabe a unique_ptr:

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

Es kann immer nur einen geben unique_ptr, der auf ein bestimmtes Objekt zeigt (es sei denn, Sie missbrauchen es, indem Sie es auf ein Vertex*und zurück werfen ). Sie können niemals eine kopieren unique_ptr, sondern nur verschieben. Wenn a unique_ptrzerstört wird (und nicht entfernt wurde), ist es sogar deletedas Objekt für Sie.

make_uniqueerstellt ein neues Vertexund hüllt es in ein unique_ptr; Die Argumente, an die Sie übergeben, make_uniquesind die Argumente, die an den Konstruktor übergeben werden.

Gibt es eine Standardmethode, um anzuzeigen, dass eine Funktion einen neuen Zeiger zurückgibt?

Nein, es gibt keinen "Standardweg" (aber es gibt eine API-Entwurfsrichtlinie, die derzeit als "Best Practice" gilt).

Aufgrund dieser Mehrdeutigkeit ("Was möchte eine Funktion, die einen Zeiger zurückgibt, von mir?") Wird es derzeit als bewährte Methode angesehen, die Lebensdauer- und Eigentumsrichtlinie über den Rückgabetyp festzulegen:

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

<vertex pointer type>kann sein std::unique_ptr("new_vertex besitzt den Zeiger nicht") oder std::shared_ptr("Clientcode besitzt den Zeiger nicht") oder etwas anderes, das eine klar definierte Besitzersemantik aufweist (z. B. Vertex const * constwürde dem Clientcode anzeigen ", lesen Sie den Adresse und Werte, aber weder ändern noch den Zeiger löschen ").

Im Allgemeinen sollten Sie keinen rohen Zeiger zurückgeben (in einigen Fällen schlägt "Praktikabilität die Reinheit").

TLDR : Es gibt eine bewährte Methode ( ja ), aber keine Standardmethode (in der Sprache).

Bearbeiten :

Dabei soll die Funktion nur innerhalb einer Klasse verwendet werden, der der Vertex gehört

Wenn die Klasse den Vertex besitzt, würde ich ihn so schreiben:

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

Ja, es gibt Dutzende von "Standards"

Die empfohlene Antwort unique_ptrist wahrscheinlich die beste Antwort, aber wenn Sie sich rohe Zeiger ansehen, hat jeder seinen eigenen Standard entwickelt.

Im allgemeinen Funktion mit dem Namen create_____oder new______oder alloc_____neigt dazu , ein neues Objekt zu implizieren.

jedoch

Bedenken Sie, dass Sie Verhaltensweisen mischen. Es ist Ihnen eigentlich egal, ob dies eine neue Instanz eines Objekts ist oder nicht. Was Sie interessiert, ist, ob der Anrufer für die Zerstörung des Objekts verantwortlich ist oder nicht. Es gibt viele APIs, die die Verantwortung für ein vorhandenes Objekt übertragen, und diese Funktionen benötigen ein übereinstimmendes Namensschema. Vielleicht give______.

Wenn Sie bereit sind, sich ein wenig von C ++ zu entfernen ...
Wenn Sie bereit sind, Objective-C als C ++ ähnlich genug zu betrachten, um eine Antwortquelle zu finden, gibt es in dieser Sprache tatsächlich eine echte Antwort. Objective-C verwaltet die Lebensdauer von Objekten mithilfe von Referenzzählern. Sie brauchten eine Möglichkeit zu beschreiben, ob Ihnen die Verantwortung für ein Objekt übertragen wurde, oder lediglich einen Verweis auf ein vorhandenes Objekt. Wenn Sie die Antwort falsch verstehen, erhalten Sie die Ref-Zählungen falsch und verlieren Objekte. Dementsprechend haben sie eine Regel aufgestellt: Jedes Objekt, das Sie zurückgeben, gehört einer anderen Person (Sie müssen also die Ref-Anzahl selbst erhöhen und verringern), mit Ausnahme von Erstellungsaufrufen, die einen bereits inkrementierten Zeiger an Sie übergeben (Sie müssen nur dekrementieren). Diese Aufrufe wurden durch den Methodennamen identifiziert. Methoden beginnend mit alloc new copyodermutableCopyhat immer ein neues Objekt zurückgegeben. Dort wurde der Standard also von der Sprache durchgesetzt.