0

假设我有两个抽象类，A1并且A2. A1有一个函数叫做foo()，A2有一个函数叫做bar()。我创建了这些基类的许多不同的子类，例如C1,C2,C3，...，它们可能继承也可能不继承A1和/或A2.我现在想遍历所有类型的类A1和所有类型的类A2并调用foo()resp bar()。我的问题是实现这一目标的最佳方法是什么？我的方法是使用保存实例的智能指针或向量C1,C2,...，即：

std::vector<C1> c1s;
std::vector<C2> c2s;
std::unique_ptr<C3> c3;
...

然后我声明两个整数，n_A1并n_A2指定每个抽象类A1和A2. 然后我定义了两个指针数组：

A1 **a1s = new A1*[n_A1];
A2 **a2s = new A2*[n_A2];

然后手动将实例的所有地址添加到这些数组中。例如，如果c1s长度为 2，c2s长度为 3，并且如果C1继承A1、C2继承A2、C3继承A1，A2我会这样做：

a1s[0]=&c1s[0];
a1s[1]=&c1s[1];
a2s[0]=&c2s[0];
a2s[1]=&c2s[1];
a2s[2]=&c2s[2];
a1s[2]=c3.get();
a2s[3]=c3.get();

因此n_A1=3，and n_A2=4and 我现在可以遍历地址数组 a1s 和 a2s 并调用函数foo()or bar()。删除包含所有这些对象的实例时，我只需要释放数组a1s和a2s.

一直被建议不要在 C++ 中使用原始指针，我想知道这是否是解决这个问题的好方法？这种方法有风险吗？有没有更好的方法来做到这一点？

4

1 回答 1

0 
class IA
{
   virtual ~IA();
}

class A1 :public  IA
{
   virtual ~A1();
   virtual void foo();
}

class A2 :public  IA
{
   virtual ~A2();
   virtual void bar();
}

class C1 :public  A1
{
   virtual ~C1();
   virtual void foo();
}
class C2 :public  A2
{
   virtual ~C2();
   virtual void bar();
}
class C3 :public A1,public A2
{
   virtual ~C3();
   virtual void foo();
   virtual void bar();
}

int main()
{
  std::vector<IA*> AllAsObjects;
  AllAsObjects.push_back(new C1());
  AllAsObjects.push_back(new C2());
  AllAsObjects.push_back(new C3());
  for (IA* Obj :AllAsObjects)
  {
    if(dynamic_cast<A1*>(Obj))
      dynamic_cast<A1*>(Obj)->foo();
    if(dynamic_cast<A2*>(Obj))
      dynamic_cast<A2*>(Obj)->bar();
  }
}

我认为这就是你所需要的

*注意这是自编译的

于 2019-02-14T11:17:46.110 回答