单身班-真的很困惑 我试图在C++中实现一个单级类，并有点困惑。好吧，假设我有以下两个类： class Animal { public: virtual int age() = 0; virtual void breed() = 0; }; class Cat : public Animal { public: Cat(); int age(); void breed(); };

这个系统涉及到更多的类。。。。（狗、鱼等）

现在我有了一个单例类，我可以只使用1个对象：

class Singleton 
{
  public:
    Animal *newAnimal(string theTypeOfAnimal);
  private:   
   static Animal* pinstance;
};                        

Animal *Singleton::newAnimal(string theTypeOfAnimal)
{
pinstance = new Cat;

}           

int main()
{        
Singleton *s;
return 0;
}      

更新：

新代码：

#include <iostream>
using namespace std;

class Animal {

public:
    virtual int age() = 0;
    virtual void breed() = 0;
};

class Cat : public Animal
{
public:
        virtual int age() { return 9; }
        virtual void breed() { }

 };
class Singleton
{
public:
    Animal *newAnimal(string theTypeOfAnimal);
  private:   
   static Animal* pinstance;
};

Animal* Singleton::pinstance = 0;


Animal *Singleton::newAnimal(string theTypeOfAnimal)
{
     this->pinstance = new Cat;
 return pinstance;
}  

 int main(int argc, char *argv[]) {

Singleton s;

Animal *myAnimal = NULL;

Animal *myAnimal = s->newAnimal("cat");

#包括
使用名称空间std；
类动物{
公众：
虚拟整数年龄（）=0；
虚空繁殖（）=0；
};
猫类：公共动物
{
公众：
虚拟整数年龄（）{return 9；}
虚空繁殖（）{}
};
单件阶级
{
公众：
动物*新动物（字符串为动物类型）；
私人：
静态动物姿态；
};
动物*Singleton:：pinstance=0；
Animal*Singleton:：newAnimal（字符串表示动物的类型）
{
此->pinstance=新猫；
回程站姿；
}  
int main（int argc，char*argv[]）{
独生子女；
动物*myAnimal=NULL；
动物*myAnimal=s->newAnimal（“猫”）；

---

}

您必须从singleton派生，而不是从target Cals派生。 单身是一种模式。您可以将其实现为模板类（通常）或派生自的基类（很少）。 经典的单身汉有：

• 私有构造函数
• 私有副本构造函数
• 私有非虚拟析构函数
• 私人经营者=
• 保存指向自身对象的指针
• 具有外部友元函数获取对象

它可以：

• 没有ctor、cctor、dtor和oper=的实现，所以尝试从派生类调用它将导致链接错误
• 私生子
• 惰性对象初始化
• 。。。还有别的吗

对于哪种实现更好，哪种实现是单例的好还是坏，还没有达成共识。 在我看来，单身对初学者来说弊大于利。除非你确定它在特定的地方需要，否则不要使用它

作为一个沙漠，一个带有智能指针的糟糕的单例模板（查找可怕的错误！）：

#包括
#包括
模板
类单例：public boost:：noncopyable
{
公众：
静态std:：shared_ptr Get（）
{
if（m_pSelf.get（）==0）
返回m_pSelf=std:：shared_ptr（newt（））；
其他的
返回m_pSelf；
}
受保护的：
Singleton（）{}
~Singleton（）{}
私人：
静态std：：共享的ptr m_pSelf；
};
模板std:：shared_ptr Singleton:：m_pSelf；

您需要明确定义静态成员：

Animal*Singleton:：pinstance=nullptr

static Animal*pinstance
类内部只是一个声明，即没有为变量分配实际空间。这样做的原因是静态成员不属于特定的对象，并且没有与宿主类的实例一起分配。静态成员与所有类实例共享，必须显式分配。
必须在其外部定义静态类对象：

Animal* Singleton::pinstance = 0;

必须在
Cat
类中定义函数：

class Cat : public Animal
{
public:
    Cat() {}
    int age() { return 7; }
    void breed() {}
};

尽可能远离单例反模式。如果您需要公共状态，请使用无状态类来封装对该公共状态的访问。公共状态迟早会被分割。@WaleedKhan我已经更新了代码并包含了错误消息！非常感谢。至于代码，虽然我不太理解。。你能看一下我上面编辑过的代码，告诉我为什么我会发布这个错误，以及我将如何修复它吗？谢谢你：）-1.关于执行问题。返回指向
T
的指针会使整个
Singleton
类变得毫无意义，因为没有任何东西可以阻止我复制
T
。事实上，拥有一个单例模板是毫无意义的，也可能只是把原来的类变成单例。谢谢你的输入，但我有点明白了，但是，我不。。我试着将动物*Singleton:：pinstance=null；但是不起作用！没有
null
，有
nullptr
，您必须在类外部全局范围内定义它。已更新代码。出现新错误：“成员引用类型‘Singleton’不是指针动物*myAnimal=s->newAnimal（“cat”）；@Phorce
myAnimal=s.newAnimal（“cat”）1）您第二次重新定义了
myAnimal
；2） 您在本地对象上使用了
->
，而不是
；
class Cat : public Animal
{
public:
    Cat() {}
    int age() { return 7; }
    void breed() {}
};