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

Question

I inherit from Base class to create two different Derived class ( Derived1 and Derived2), then I place them into a vector. Lets say I want to call the function of Derived class based on the type of class.

pseudocode:

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

An attempt:

#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;
}

dynamic cast is usually code smell, evidence that your interface Base is missing functionality. Once you dynamic cast, your interface goes from what Base states to the layout and contents of your entire type heirarchy.

Instead, add:

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

to Base , and override in derived.

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;
}

now we no longer care which specific derived type we used to implement Z or Flag .

From this SO answer there is a link to a reference std::optional implementation that uses the boost software license and is one header file.

Answer 2

check the good ol' dynamic_cast trick – if it's castable, it's of the right type.

Anyway, I'd recommend not using this design pattern (check types at runtime and decide based on that), but put the logic into the derived classes; have a common method that either does the one or the other thing:

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;
  }

}

The STL-style way of dealing with this would be templates and type traits – but I personally consider that to be a nuisance.