Question

我从Base类继承创建两个不同的Derived类（Derived1和Derived2），然后将它们放入向量中。假设我想根据类的类型调用Derived类的函数。

伪代码：

if holder[1] stored Derived1 then I want to call GetZ() 
else if holder[1] stored Derived2 then I want to GetFlag().

尝试：

#include <iostream>
#include <memory>
#include <vector>

class Base {
 public:
  Base(int x, int y) : x_(x), y_(y) {}

  int GetX() { return x_; }
  int GetY() { return y_; }

 private:
  int x_;
  int y_;
};

class Derived1 : public Base {
 public:
  Derived1(int x, int y, int z) : Base(x, y), z_(z) {}

  int GetZ() { return z_; }

 private:
  int z_;
};

class Derived2 : public Base {
 public:
  Derived2(int x, int y, bool flag) : Base(x, y), flag_(flag) {}

  bool GetFlag() { return flag_; }

 private:
  bool flag_;
};

std::vector<std::shared_ptr<Base>> holder;
void print();
int main() {
  holder.push_back(std::make_shared<Derived1>(3, 4, 5));
  holder.push_back(std::make_shared<Derived2>(6, 7, true));

  print();
}

void print(){

  for(auto& it : holder){
    // call this if "it" is Derived2
    // else call it->GetX()
    // currently this gives compilation error 
    // because of object slicing
    std::cout << it->GetFlag() << std::endl;
  }

}

Answer 1

for(auto& it : holder){
  if (auto* D1 = dynamic_cast<Derived1*>(it->get())) {
    std::cout << D1->GetZ();
  } else if (auto* D2 = dynamic_cast<Derived2*>(it->get())) {
    std::cout << D2->GetFlag();
  }
  std::cout << std::endl;
}

动态强制转换通常是代码异味，证明您的界面Base缺少功能。动态转换后，您的界面会从Base状态变为整个类型层次结构的布局和内容。

相反，添加：

virtual boost::optional<int> GetZ() { return {}; }
virtual boost::optional<bool> GetFlag() { return {}; }

到Base，并覆盖派生。

for(auto& it : holder){
  if (auto Z = it->GetZ()) {
    std::cout << *Z;
  } else if (auto flag = it->GetFlag())
    std::cout << *flag;
  }
  std::cout << std::endl;
}

现在我们不再关心我们用于实施Z或Flag的具体派生类型。

来自this SO answer的link to a reference std::optional implementation使用了升级软件许可证，是一个头文件。

Answer 2

检查好的＆＃39; dynamic_cast诀窍 - 如果它是可投递的，那就是正确的类型。

无论如何，我建议不使用这种设计模式（在运行时检查类型并根据它确定），但将逻辑放入派生类中;有一个共同的方法，要么做一个或另一个：

class Base {
 public:
  Base(int x, int y) : x_(x), y_(y) {}

  int GetX() { return x_; }
  int GetY() { return y_; }

  virtual int do_the_right_thing();

 private:
  int x_;
  int y_;
};

class Derived1 : public Base {
 public:
  Derived1(int x, int y, int z) : Base(x, y), z_(z) {}

  int GetZ() { return z_; }

  virtual int do_the_right_thing() { return GetZ() };

 private:
  int z_;
};

class Derived2 : public Base {
 public:
  Derived2(int x, int y, bool flag) : Base(x, y), flag_(flag) {}

  bool GetFlag() { return flag_; }

  virtual int do_the_right_thing() { return GetFlag() };

 private:
  bool flag_;
};


void print(){

  for(auto& it : holder){
    // call this if "it" is Derived2
    // else call it->GetX()
    // currently this gives compilation error 
    // because of object slicing
    std::cout << it->do_the_right_thing() << std::endl;
  }

}

STL风格的处理方式是模板和类型特征 - 但我个人认为这是一种麻烦。

如何从包含基类指针的容器中调用派生类函数（基于其类型）？

2 个答案: