为什么不能将多态派生类嵌套在基类中？

Question

例如，我试图做这样的事情：

class Animal { 
public: 
    virtual const char *says() const = 0; 

    static Animal *makeLion() { return new Lion(); } 
    static Animal *makeTiger() { return new Tiger(); } 
    static Animal *makePig() { return new Pig(); } 

private: 
    class Lion : public Animal { // error: invalid use of incomplete type ‘class Animal’ 
    public: 
     virtual const char *says() const 
     { 
      return "roar"; 
     } 
    }; 

    class Tiger : public Animal { // error: invalid use of incomplete type ‘class Animal’ 
    public: 
     virtual const char *says() const 
     { 
      return "meow"; 
     } 
    }; 

    class Pig : public Animal { // error: invalid use of incomplete type ‘class Animal’ 
    public: 
     virtual const char *says() const 
     { 
      return "That\'s all Folks!"; 
     } 
    }; 
}; 

编译器抱怨Animal是一个不完整的类型。但是为什么Animal是一个不完整的类型，如果不需要内部类定义来定义外部类本身（因为没有内部类类型的非静态变量由外部类中的值声明）？

有没有办法解决这个问题，或者更好的方法来做我想做的事情？

Answer 1

类是不完整的，直到关闭大括号}的类定义。

重新“有这个”围绕一个方法，你可以做这样的事情：

struct A 
{ 
    struct B; 
}; 

struct A::B 
    : A 
{}; 

但它不是一个常见的模式。我不记得曾经见过它。

Answer 2

有没有办法解决这个问题，或者是一个更好的方法来做我想做的事情？

请勿使用嵌套类。只需将派生类从Animal中移出即可。

---

在一个单独的说明，具有功能

static Animal *makeLion() { return new Lion(); } 
static Animal *makeTiger() { return new Tiger(); } 
static Animal *makePig() { return new Pig(); } 

在Animal是设计不良的症状。一个基类应该尽可能地不依赖于派生它的类。

---

这里有一个更清洁的接口和实现一个建议：

Animal.h：

namespace AnimalsNamespace 
{ 
    // The base class 
    class Animal 
    { 
     public: 
     virtual const char *says() const = 0; 
    }; 


    // Functions to construct objects of various sub-types of Animal. 
    // Moving these out of Animal and putting them in the namespace makes 
    // Animal a little bit cleaner. 

    Animal* makeLion(); 
    Animal* makeTiger(); 
    Animal* makePig(); 
} 

Animal.cpp：

namespace AnimalsNamespace 
{ 
    class Lion : public Animal 
    { 
     public: 
     virtual const char *says() const 
     { 
      return "roar"; 
     } 
    }; 

    class Tiger : public Animal 
    { 
     public: 
     virtual const char *says() const 
     { 
      return "meow"; 
     } 
    }; 

    class Pig : public Animal 
    { 
     public: 
     virtual const char *says() const 
     { 
      return "That\'s all Folks!"; 
     } 
    }; 

    Animal* makeLion() { return new Lion(); } 
    Animal* makeTiger() { return new Tiger(); } 
    Animal* makePig() { return new Pig(); } 
} 

Answer 3

一种可能的解决方案是将狮子，老虎，猪的定义在功能范围：

class Animal { 
public: 
    virtual ~Animal() = default; 
    virtual const char *says() const = 0; 

    static std::unique_ptr<Animal> makeLion() 
    { 
     class Lion : public Animal 
     { 
     public: 
      virtual const char *says() const override 
      { 
       return "roar"; 
      } 
     }; 
     return std::make_unique<Lion>(); 
    } 
    static std::unique_ptr<Animal> makeTiger() { 
     class Tiger : public Animal 
     { 
     public: 
      virtual const char *says() const override 
      { 
       return "meow"; 
      } 
     }; 
     return std::make_unique<Tiger>(); 
    } 
    static std::unique_ptr<Animal> makePig() { 
     class Pig : public Animal 
     { 
     public: 
      virtual const char *says() const override 
      { 
       return "That\'s all Folks!"; 
      } 
     }; 
     return std::make_unique<Pig>(); 
    } 
}; 

int main() {  
    std::cout << Animal::makeLion()->says() << std::endl; 
} 

Demo。

Answer 4

糟糕的设计。制作一个物体不应该在Animal类中完成。考虑重新设计像类：

class Animal 
{ 
public: 
    virtual const char* says() const = 0; 
}; 

class Lion : public Animal 
{ 
public: 
    virtual const char *says() const 
    { 
     return "roar"; 
    } 
}; 

class Tiger : public Animal 
{ 
public: 
    virtual const char *says() const 
    { 
     return "meow"; 
    } 
}; 

class Pig : public Animal 
{ 
public: 
    virtual const char *says() const 
    { 
     return "That\'s all Folks!"; 
    } 
}; 

然后用这样的：

Animal* p = new Pig; 
cout << p->says() << endl; 

否则，您必须添加makeXXX（）函数，每次添加一种新的时间。