C++ 静态方法返回类'；s共享\u ptr

在下面的代码段中，

MyClass

有一个返回其共享指针的静态方法。为了使代码简洁，我们使用别名

MyClassPtr

表示

std:：shared\u ptr

但是，为了实现这一点，我们在声明共享指针别名之前声明该类，然后在实际的类声明之后声明共享指针别名。看起来很冗长

有没有办法重新组织代码以便

• 保留

  MyClassPtr

  别名（在整个项目中共享）
• 没有两次“声明”

  MyClass

代码如下：

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

class MyClass {
public:
    static MyClassPtr createMyClassInstance();

private:
/*Other members & methods*/
}

class-MyClass；
使用MyClassPtr=std:：shared\u ptr；
类MyClass{
公众：
静态MyClassPtr createMyClassInstance（）；
私人：
/*其他成员和方法*/
}

---

我同意当前的实现。但如果代码可以改进，我想征求有经验的家伙的建议。

将返回类型替换为自动：

class MyClass {
public:
    static auto createMyClassInstance();

private:
/*Other members & method*/
}

---

：

将返回类型替换为自动：

class MyClass {
public:
    static auto createMyClassInstance();

private:
/*Other members & method*/
}

---

：

使

Ptr

成为成员类型：

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

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

// ...

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

class-MyClass{
公众：
使用Ptr=std:：shared\u Ptr；
静态Ptr createMyClassInstance（）；
私人：
/*其他成员和方法*/
};
// ...
MyClass:：Ptr p=MyClass:：createMyClassInstance（）；

使

Ptr

成为成员类型：

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

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

// ...

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

class-MyClass{
公众：
使用Ptr=std:：shared\u Ptr；
静态Ptr createMyClassInstance（）；
私人：
/*其他成员和方法*/
};
// ...
MyClass:：Ptr p=MyClass:：createMyClassInstance（）；

当您询问如何简化代码时，您的问题有些模糊，但您没有提供任何真正的代码，只有类定义的概要。相反，我试图回答一个更明智的问题，即如何改进代码。我建议

避免使用别名

MyClassPtr

，它并不是真正必要的（如果使用

auto

，则不应使用太多），但更重要的是，它减少了代码的冗长性，从而降低了代码的可读性，因为从其名称来看，

MyClassPtr

指的是

共享的\u ptr

如果坚持使用智能指针的简写，可以在类定义之后定义，从而避免向前声明

将

MyClass:：createMyClassInstance

重命名为更详细的名称，我建议

MyClass:：createSharedPtr

（无需再次在函数名中添加

MyClass

）

别忘了

在类定义之后

因此,

class-MyClass
{
公众：
静态std:：shared_ptr createSharedPtr（）；
私人：
/*其他成员和方法*/
};
使用MyClassSharedPtr=std:：shared_ptr；//可选择的

---

好的代码应该是不言自明的，因此不一定是最简洁的，尽管必须避免冗余。

当你问如何简化代码时，你的问题有些模糊，但你没有提供任何真正的代码，只有类定义的概要。相反，我试图回答一个更明智的问题，即如何改进代码。我建议

避免使用别名

MyClassPtr

，它并不是真正必要的（如果使用

auto

，则不应使用太多），但更重要的是，它减少了代码的冗长性，从而降低了代码的可读性，因为从其名称来看，

MyClassPtr

指的是

共享的\u ptr

如果坚持使用智能指针的简写，可以在类定义之后定义，从而避免向前声明

将

MyClass:：createMyClassInstance

重命名为更详细的名称，我建议

MyClass:：createSharedPtr

（无需再次在函数名中添加

MyClass

）

别忘了

在类定义之后

因此,

class-MyClass
{
公众：
静态std:：shared_ptr createSharedPtr（）；
私人：
/*其他成员和方法*/
};
使用MyClassSharedPtr=std:：shared_ptr；//可选择的

好的代码应该是不言自明的，因此不一定是最简洁的，尽管必须避免冗余

有没有办法重新组织代码以便

（1） 保留MyClassPtr别名（在整个项目中共享）

（2） 没有两次“声明”MyClass

如果您接受两次声明

MyClassPtr

，您可以在类内声明它并在类外“导出”它

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

#包括
类MyClass
{
公众：
使用MyClassPtr=std:：shared\u ptr；
静态MyClassPtr createMyClassInstance（）；
私人：
/*其他成员和方法*/
};
使用MyClassPtr=MyClass:：MyClassPtr；
int main（）
{
MyClassPtr np{nullptr}；
}

有没有办法重新组织代码以便

（1） 保留MyClassPtr别名（在整个项目中共享）

（2） 没有两次“声明”MyClass

如果您接受两次声明

MyClassPtr

，您可以在类内声明它并在类外“导出”它

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

#包括
类MyClass
{
公众：
使用MyClassPtr=std:：shared\u ptr；
静态MyClassPtr createMyClassInstance（）；
私人：
/*其他成员和方法*/
};
使用MyClassPtr=MyClass:：MyClassPtr；
int main（）
{
MyClassPtr np{nullptr}；
}

您可能仍然希望在类之后使用

语句。是的，为了简洁起见，其他类将使用
MyClassPtr
。这就是本例中使用
的全部要点。您可能仍然希望在类之后使用
using
语句。是的，为了简洁起见，其他类将使用
MyClassPtr
。这就是在本例中使用
的全部要点。谢谢，
createMyClassInstance
只是我随机选择的一个名称，以说明该方法的用途。我想知道有没有什么方法可以避免将MyClass声明为“两次”呢