C++ C++；向量基类与继承

对于我的项目，我有以下课程结构：

class Base
{
        enum class type
    {
        Derived1,
        Derived2
    }

    int getType() {return type;};

    type        type;
    //general methods & attributes
}

class Derived1 : public Base
{
    //specific methods & attributes
    void        uniqueSpecificMethodOfDerived1();
}

class Derived2 : public Base
{
    //specific methods & attributes
    void        uniqueSpecificMethodOfDerived2();
}

class Core
{
    vector<unique_ptr<Base>>        tab;
    void                            iterate();
}

void        Core::iterate()
{
    tab.emplace_back(new Derived1());
    tab.emplace_back(new Derived2());

    vector<unique_ptr<Base>>::iterator it;

    for (it = tab.begin(); it != tab.end(); ++it)
    {
        if ((*it)->getType())
            (*it)->uniqueSpecificMethodOfDerived1(); //unknow function Can't resolve 'uniqueSpecificMethodOfDerived1()'
        if ((*it)->getType())
            (*it)->uniqueSpecificMethodOfDerived2(); //unknow function Can't resolve 'uniqueSpecificMethodOfDerived1()'
    }
}

类基
{
枚举类类型
{
嘲笑1，
嘲笑的2
}
int getType（）{return type；}；
类型；
//一般方法和属性
}
类Derived1：公共基
{
//特定方法和属性
void uniqueSpecificMethodOfDerived1（）；
}
派生类2：公共基
{
//特定方法和属性
void uniqueSpecificMethodOfDerived2（）；
}
类核心
{
向量标签；
void iterate（）；
}
void Core:：iterate（）
{
tab.向后放置（新衍生1（））；
tab.向后放置（新衍生2（））；
向量：：迭代器；
for（it=tab.begin（）；it！=tab.end（）；+it）
{
if（（*it）->getType（）
（*it）->UniqueSpecificMethodOfDelived1（）；//未知函数无法解析'UniqueSpecificMethodOfDelived1（）'
if（（*it）->getType（）
（*it）->UniqueSpecificMethodOfDelived2（）；//未知函数无法解析'UniqueSpecificMethodOfDelived1（）'
}
}

我的问题是我无法找到这个向量中派生类的具体方法。我不想使用多态性，因为这个函数完全不同，其他派生类不需要它

我怎么能做到

我的问题是我无法找到这个向量中派生类的具体方法。我不想使用多态性，因为这个函数完全不同，其他派生类不需要它

我怎么能做到

该语言提供了两种机制来访问给定基类指针/引用的派生类中的函数

通过多态性

通过

dynmaic\u cast

直接访问派生类函数

您可以构建函数层，允许您使用

dynamic_-cast

访问派生类的直接接口，而无需显式使用客户端代码，但如果不选择使用多态性，则在某些时候必须使用

dynamic_-cast

下面是您的代码的更新版本，它直接使用

dynamic\u cast

class Base
{
   public:
      virtual ~Base() {}
};

class Derived1 : public Base
{
   public:
      void uniqueSpecificMethodOfDerived1() {}
};

class Derived2 : public Base
{
   public:
      void uniqueSpecificMethodOfDerived2(){}
};

class Core
{
   vector<unique_ptr<Base>>        tab;
   void                            iterate();
};

void Core::iterate()
{
   tab.emplace_back(new Derived1());
   tab.emplace_back(new Derived2());

   vector<unique_ptr<Base>>::iterator it;

   for (it = tab.begin(); it != tab.end(); ++it)
   {
      Base* ptr = (*it).get();
      Derived1* ptr1 = nullptr;
      Derived2* ptr2 = nullptr;
      if ( (ptr1 = dynamic_cast<Derived1*>(ptr)) != nullptr )
      {
         ptr1->uniqueSpecificMethodOfDerived1();
      }

      if ( (ptr2 = dynamic_cast<Derived2*>(ptr)) != nullptr )
      {
         ptr2->uniqueSpecificMethodOfDerived2();
      }
   }
}

类基
{
公众：
虚拟~Base（）{}
};
类Derived1：公共基
{
公众：
void uniqueSpecificMethodOfDelived1（）{}
};
派生类2：公共基
{
公众：
void uniqueSpecificMethodOfDelived2（）{}
};
类核心
{
向量标签；
void iterate（）；
};
void Core:：iterate（）
{
tab.向后放置（新衍生1（））；
tab.向后放置（新衍生2（））；
向量：：迭代器；
for（it=tab.begin（）；it！=tab.end（）；+it）
{
Base*ptr=（*it.get（）；
Derived1*ptr1=nullptr；
Derived2*ptr2=nullptr；
if（（ptr1=动态_-cast（ptr））！=nullptr）
{
ptr1->uniqueSpecificMethodOfDerived1（）；
}
如果（（ptr2=动态_-cast（ptr））！=nullptr）
{
ptr2->uniqueSpecificMethodOfDerived2（）；
}
}
}

如果这些函数完全不同，为什么要将这些不同的对象填充到同一个向量中？您至少需要将指针向下转换到正确的类型（使用

dynamic\u cast

）-

Base

类显然对其子类的方法一无所知（因为它们不是虚拟的）[我假设你有实际的继承权-这种做事方式有点违背继承权的目的]因为这些派生类共享主类提供的许多方法和属性。实际上，它们是相同类型的对象。Entity是我的基类，敌军/玩家/射击是Entity的派生类。您可能应该研究一下-我怀疑它更适合您的需要通过非虚拟方式访问派生类型的成员指向基类型的指针/引用是一种反模式，表明类模型不好。您可能需要重新考虑您的设计。