Static method return class's shared_ptr

Question

In the following snippet, MyClass has a static method which returns its shared pointer. To make to code concise, we use the alias MyClassPtr for std::shared_ptr<MyClass>.

However, to accomplish this, we declare the class before declaring the shared pointer alias, which then follows the actual class declaration. It looks verbose.

Is there some way to reorganize the code so that

keep the MyClassPtr alias (it is shared across the project)
without "declaring" MyClass twice

code below:

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

class MyClass {
public:
    static MyClassPtr createMyClassInstance();

private:
/*Other members & methods*/
}

I'm OK with the current implementation. But I would like to seek experienced guy's advice if the code can be improved.

Related? Duplicate? https://stackoverflow.com/questions/1008019/c-singleton-design-pattern — Galik, Sep 07 '17 at 00:02
There is nothing to do with the Singleton pattern here... No idea why it is a duplicate... — hackjutsu, Sep 07 '17 at 17:37

score 3 · Answer 1 · edited Jun 20 '20 at 09:12

Your question is somewhat vague, as you ask how the code can be simplified, yet you fail to provide any real code, only the outline of a class definition. Instead, I try to answer the more sensible question of how to improve your code. I suggest

Avoid the alias MyClassPtr, it's not really necessary (it should not be used much if you use auto) but more importantly reduces verbosity and hence readability of the code, since it's not obvious from its name that MyClassPtr refers to a shared_ptr.

If you insist on having a shorthand for the smart pointer, you can define this after the class definition, thus avoiding the forward declaration
Rename MyClass::createMyClassInstance to something more verbose, I suggest MyClass::createSharedPtr (no need to have MyClass in the function name again).
Don't forget the ; after a class definition.

Thus,

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

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

IMHO, good code should be self-explanatory and hence not necessarily most concise/brief, though redundancies must be avoided.

Thanks, `createMyClassInstance` is just a random name I pick up to illustrate the method's purpose. I'm wondering is there any way to avoid declaring `MyClass` "twice". — hackjutsu, Sep 06 '17 at 23:51
There is nothing wrong with that. You only define it once, but can declare it as often as you like. — Walter, Sep 06 '17 at 23:52

score 2 · Answer 2 · answered Sep 06 '17 at 23:40

2

Make Ptr a member type:

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

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

// ...

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

answered Sep 06 '17 at 23:40

Daniel H

7,223
2
26
41

score 0 · Answer 3 · answered Sep 06 '17 at 23:25

0

Replace the return type with auto:

class MyClass {
public:
    static auto createMyClassInstance();

private:
/*Other members & method*/
}

Demo:

answered Sep 06 '17 at 23:25

Steephen

14,645
7
40
47

You might still want the `using` statement, just after the class. – Daniel H Sep 06 '17 at 23:30
Yes, other classes will use `MyClassPtr` for brevity. That's the whole point of `using` in this case. – hackjutsu Sep 06 '17 at 23:45

score 0 · Accepted Answer · edited Jun 20 '20 at 09:12

is there some way to reorganize the code so that

(1)keep the MyClassPtr alias (it is shared across the project)

(2) without "declaring" MyClass twice

You you accept to declare MyClassPtr twice, you can declare it inside the class and "export" it outside

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

Static method return class's shared_ptr

4 Answers4