C++ 我应该如何在模板类中存储一些不同的类对象？

所以，我必须创建一个模板类来存储另一个类的对象，比如向量或列表。我决定写一个简单的例子，比如一些动物的地图集。 直到现在我才明白这一点，但我不能用动物对象实例化我的向量。我得到这个错误：

main.cpp|60|error: could not convert <'brace-enclosed initializer list >()' from 'brace-enclosed initializer list>' to 'Animal'

---

main.cpp | 60 |错误：无法转换
Atlas
将只存储动物，而不是从
Animal
派生的任何内容。
新的T[length]{}
表达式将尝试默认构造
Animal
，但由于没有
Animal
默认构造函数，该操作失败。可能
Atlas
应包含
std:：vector
。如果必须能够初始化一个长度为但没有内容的
Atlas
，那么它将需要处理包含一些空指针的可能性。@1201程序啊，我的错。我对OOP这个概念还不熟悉，所以我仍在努力理解它。我非常感谢你，伙计。我想知道，我是否可以在模板类中设置数组长度的静态int？我将为此模板类重载“+=”运算符，并且我希望使用静态整数使我的长度自动递增通常只更改一个对象，而不是该类型的所有对象，因此长度不应是静态的。如果你使用
std:：vector
而不是原始数组，那么
vector
总是可以告诉你它自己的长度。这似乎是一个解决方案，但问题是我想重载
+=
操作符来插入动物，例如鸟，当我插入一个对象时，我希望m_length递增，并且m_length+1。现在，我尝试创建一个函数setlength，如图所示：
void Atlas:：setlength（int j）{m_length=j；}
但是当我尝试初始化AtlasAnimal[j]=Animal p；它会出现内存泄漏，我想这是因为我使长度变大了，但在数组的末尾有一个空对象。我该怎么处理？我应该试着把我所有的课程都分配给dinamyc吗？
#include <iostream>
#include <assert.h>
#include <list>
using namespace std;
class Animal {
protected:
    std::string m_name;
    Animal (std::string name): m_name {name} {}
public:
    virtual std::string regn() const { return "???"; }
    virtual ~Animal(){
    cout << "Destructor animal"<<'\n';}
};
class Nevertebrate : public Animal{
public:
    virtual std::string regn() const { return "nevertebrate";}
    virtual ~Nevertebrate();
};
class Vertebrate: public Animal {
protected:
  /*  std::string m_name;
    Vertebrate (std::string name)
        :m_name {name} {} */
        Vertebrate (std::string name)
            : Animal {name} {}

public:
    virtual std::string regn() const { return "vertebrate";}
    virtual ~Vertebrate(){
    cout<<"Destructor vertebrate"<<'\n';};
};


class bird: public Vertebrate {
public:
    bird(std::string name)
        : Vertebrate{ name }{}
    void set_name (std::string nume){
    m_name = nume;}

    std::string get_name(){
    return m_name;}
    virtual std::string regn() const {return "pasare";}
    virtual ~bird (){
    cout << "destructor bird"<<'\n';}
 };

template <class T>
class Atlas
{
private:
    int m_length{};
    T* m_data{};

public:

    Atlas(int length)
    {
        assert(length > 0);
        m_data = new T[length]{};
        m_length = length;
    }

    Atlas(const Atlas&) = delete;
    Atlas& operator=(const Atlas&) = delete;

    ~Atlas()
    {
        delete[] m_data;
    }

    void erase()
    {
        delete[] m_data;

        m_data = nullptr;
        m_length = 0;
    }

    T& operator[](int index)
    {
        assert(index >= 0 && index < m_length);
        return m_data[index];
    }

    int getLength() const;
};
template <class T>
int Atlas<T>::getLength() const // note class name is Array<T>, not Array
{
  return m_length;
}

int main()
{
   Atlas<Animal> AtlasAnimal(10);

    return 0;
}