多态和函数重载？

Question

我有一个Base类和一个Base的Derived类

struct Base{};
struct Derived: public Base{};

我想制作一个接受Base*的函数，但在传递Derived*时具有不同的功能。

void myFunc(Base* base){
 std::cout << "myFunc(base)" << std::endl; 
}

void myFunc(Derived* derived){
 std::cout << "myFunc(derived)" << std::endl;
}

我的问题是当我尝试使用多态时，该函数的行为不符合预期，因为我总是传递Base*的。

Base* base = new Base();
Base* derived = new Derived();

myFunc(base);
myFunc(derived);

输出：

myFunc(base)
myFunc(base)

期望的输出：

myFunc(base)
myFunc(derived)

我不能使用像 - (Derived*)derived - 这样的强制转换的原因是因为我使用的是Base*数组

#include <iostream>

struct Base{};    
struct Derived: public Base{};

void myFunc(Base* base){
 std::cout << "myFunc(base)" << std::endl; 
}

void myFunc(Derived* derived){
 std::cout << "myFunc(derived)" << std::endl;
}

void myFunc(Base** bases, size_t count){
 for(auto i = 0; i < count; i++){
  myFunc(bases[i]);
 }
}

int main(){
 Base* bases[2];
 bases[0] = new Base();
 bases[1] = new Derived();

 myFunc(bases, 2);
}

我不能让myFunc成为 base 的虚成员函数的原因是因为我想将myFunc的功能封装在一个单独的类中以避免一个单一的基类。

#include <iostream>

struct Base{};

struct Derived: public Base{};

struct DoesStuff{
 void doStuff(Base* base){
  std::cout << "doStuff(base)" << std::endl; 
 }

 void doStuff(Derived* derived){
  std::cout << "doStuff(derived)" << std::endl;
 }

 void doStuff(Base** bases, size_t count){
  for(auto i = 0; i < count; i++){
   doStuff(bases[i]);
  }
 }
};

struct DoesOtherStuff{
 void doOtherStuff(Base* base){
  std::cout << "doOtherStuff(base)" << std::endl; 
 }

 void doOtherStuff(Derived* derived){
  std::cout << "doOtherStuff(derived)" << std::endl;
 }

 void doOtherStuff(Base** bases, size_t count){
  for(auto i = 0; i < count; i++){
   doOtherStuff(bases[i]);
  }
 }
};

int main(){
 Base* bases[2];
 bases[0] = new Base();
 bases[1] = new Derived();

 DoesStuff stuffDoer;
 DoesOtherStuff otherStuffDoer;

 stuffDoer.doStuff(bases, 2);
 otherStuffDoer.doOtherStuff(bases, 2);
}

我如何让myFunc知道Base*秘密地是Derived* 。 我想我可以使用typeid ，但我不确定这是最合适的解决方案。 如果我错了纠正我。

Answer 1

为了通过多态使其工作，请执行以下操作：

1. 在 Base 类中创建一个虚拟成员函数，该函数执行您想要为 Base 类执行的操作。

2. 覆盖派生类中的成员函数，并让它为派生类执行您想要的操作。

这就是多态的本质。 它对您的非成员或自由函数不起作用的原因是因为它们都传递了基类指针。