Rückgabewerte der statischen Methode shared_ptr

Question

Im folgenden Codefragment verfügt MyClass über eine statische Methode, die den gemeinsamen Zeiger zurückgibt. Um den Code übersichtlich zu gestalten, verwenden wir den Alias ​​MyClassPtr für std::shared_ptr<MyClass>.

Um dies zu erreichen, deklarieren wir jedoch die Klasse vor der Deklaration des Shared-Pointer-Alias, der dann der eigentlichen Klassendeklaration folgt. Es sieht ausführlich aus.

Gibt es eine Möglichkeit, den Code so zu reorganisieren, dass

• halten den MyClassPtr alias (es über das Projekt gemeinsam genutzt wird)
• ohne "erklärt" MyClass zweimal

Code unten:

class MyClass; 
using MyClassPtr = std::shared_ptr<MyClass>; 

class MyClass { 
public: 
    static MyClassPtr createMyClassInstance(); 

private: 
/*Other members & methods*/ 
} 

Ich bin OK mit dem aktuellen Imp Lementierung. Aber ich möchte den Ratschlag des erfahrenen Kerls suchen, wenn der Code verbessert werden kann.

Answer 1

ist es eine Möglichkeit, den Code so zu reorganisieren, dass

(1) halten den MyClassPtr Alias ​​(es über das Projekt gemeinsam genutzt wird)

(2) ohne "erklärt" MyClass zweimal

Sie akzeptieren Sie MyClassPtr zweimal zu erklären, können Sie es innerhalb der Klasse deklarieren und „Export“ nach draußen

#include <memory> 

class MyClass 
{ 
    public: 
     using MyClassPtr = std::shared_ptr<MyClass>; 

     static MyClassPtr createMyClassInstance(); 

    private: 
     /*Other members & methods*/ 
}; 

using MyClassPtr = MyClass::MyClassPtr; 


int main() 
{ 
    MyClassPtr np { nullptr }; 
} 

Answer 2

mit automatischer den Rückgabetyp ersetzen:

class MyClass { 
public: 
    static auto createMyClassInstance(); 

private: 
/*Other members & method*/ 
} 

Demo:

Answer 3

Ptr eine Art Mitglied Hersteller:

class MyClass { 
public: 
    using Ptr = std::shared_ptr<MyClass>; 
    static Ptr createMyClassInstance(); 

private: 
/*Other members & method*/ 
}; 

// ... 

MyClass::Ptr p = MyClass::createMyClassInstance(); 

Answer 4

ist Ihre Frage etwas vage, wie Sie fragen, wie der Code sei vereinfacht, aber Sie versäumen es, einen echten Code, nur die Gliederung einer Klasse definiti auf. Stattdessen versuche ich, die vernünftigere Frage zu beantworten, wie man Ihren Code verbessern kann. Ich schlage vor,

1. Vermeiden Sie den Alias ​​MyClassPtr, es ist nicht wirklich notwendig (es ist nicht viel verwendet werden sollten, wenn Sie auto verwenden), aber was noch wichtiger ist reduziert Ausführlichkeit und damit die Lesbarkeit des Codes, da er aus seinem Namen nicht offensichtlich ist, dass MyClassPtr bezieht sich auf eine shared_ptr.

   Wenn Sie darauf bestehen, eine Abkürzung für den Smart-Pointer auf, so können Sie diese definieren nach die Klassendefinition, damit die Vorwärtsdeklaration zu vermeiden

2. MyClass::createMyClassInstance etwas umbenennen ausführlicher, schlage ich MyClass::createSharedPtr (keine Notwendigkeit, wieder im Funktionsnamen MyClass haben).

3. Vergessen Sie nicht die ; nach einer Klassendefinition. So

,

class MyClass 
{ 
public: 
    static std::shared_ptr<MyClass> createSharedPtr();  
private: 
    /* Other members & methods */ 
}; 

using MyClassSharedPtr = std::shared_ptr<MyClass>; // optional 

IMHO, sollte gut Code selbsterklärend und daher nicht unbedingt knappste/kurze, wenn auch Redundanzen vermieden werden muss.