C++ 运行相同函数名C+；的多个类的列表+；

我有多个具有如下相同功能的类

class A
{
  void display()
  {
    // display something
  }
};

class B
{
  void display()
  {
    // display something two
  }
};

我想将差异类存储在一个列表或一个向量和循环中，以使用相同的名称调用相同的函数

int main()
{
  A * a;

  B * b;

  //list or vector to store object

  std::vector < Something that can store different class > listofclass;

  listofclass.emplace_back(a);

  listofclass.emplace_back(b);

  for (int i = 0; i < listofclass.size(); i++)

  {

    listofclass[i].display();

  }
}

intmain（）
{
A*A；
B*B；
//用于存储对象的列表或向量
std:：vector<可以存储不同类的东西>listofclass；
类的列表。放置在后面（a）；
类的列表。放置在后面（b）；
for（int i=0；i

这样做可能吗？ 因为有不同的类，有不同的目的，现在我试着把它们组合在一起

---

或者有其他替代方法来实现类似的功能

解决此问题的方法是使用多态性。创建一个超类，该超类包含该函数的纯虚拟版本，并允许a和B从该类继承。通过这样做，您可以将任何类型A或B的指针动态转换为超类类型，您已经在超类类型上定义了显示函数

这会让你得到这样的东西

C类{
公众：
虚空显示（）=0；
virtual~C（）=默认值；
};
A类：公共C类{
公众：
void display（）覆盖{
std:：cout解决此问题的一种方法是使用多态性。您可以创建一个超类，其中包含此函数的纯虚拟版本，并让A和B都从该类继承。通过这样做，您可以将A或B类型的任何指针动态转换到您定义了显示函数的超类类型

这会让你得到这样的东西

C类{
公众：
虚空显示（）=0；
virtual~C（）=默认值；
};
A类：公共C类{
公众：
void display（）覆盖{
std:：cout您有两种解决此问题的方法：

使用继承，只需创建一个抽象类作为类的接口。在
类a
和
类B
中，只需从该接口继承，并在std:：vector中保持指向基类的指针
#包括
#包括
#包括
类接口显示{
公众：
虚空显示（）=0；
虚拟~Interface_display（）{}；
};
A类：公共界面显示
{
公众：
void display（）覆盖
{
std:：cout您有两种解决此问题的方法：

使用继承，只需创建一个抽象类作为类的接口。在
类a
和
类B
中，只需从该接口继承，并在std:：vector中保持指向基类的指针
#包括
#包括
#包括
类接口显示{
公众：
虚空显示（）=0；
虚拟~Interface_display（）{}；
};
A类：公共界面显示
{
公众：
void display（）覆盖
{
std:：cout如果控制
A
和
B
的定义，则可以编写一个公共基类，并让它们继承它

class can_display {
public:
  virtual void display() = 0;
  virtual ~can_display() = default;
};

class A : public can_display 
{
  void display() override
  {
    // display something
  }
};

class B : public can_display 
{
  void display() override
  {
    // display something two
  }
};

int main()
{
  A a;

  B b;

  std::vector<can_display *> displayables;

  displayables.push_back(&a);

  displayables.push_back(&b);

  for (can_display * displayable : displayables)
  {
    displayable->display();
  }
}

如果控制
A
和
B
的定义，则可以编写一个公共基类，并让它们继承它

class can_display {
public:
  virtual void display() = 0;
  virtual ~can_display() = default;
};

class A : public can_display 
{
  void display() override
  {
    // display something
  }
};

class B : public can_display 
{
  void display() override
  {
    // display something two
  }
};

int main()
{
  A a;

  B b;

  std::vector<can_display *> displayables;

  displayables.push_back(&a);

  displayables.push_back(&b);

  for (can_display * displayable : displayables)
  {
    displayable->display();
  }
}

你在看多态性吗？你在看多态性吗？这不是“方式”要解决这个问题，这只是一种方法！如果类不相关，这肯定不是方法！为什么要动态强制转换？它不需要，因为您将有虚拟表。请您删除所有强制转换的内容。所有这些强制转换都是错误的！您有没有删除的
new
，以及没有虚拟析构函数的多态类型，两者都是ca为烦恼而抱怨这不是“方式”要解决这个问题，这只是一种方法！如果类不相关，这肯定不是方法！为什么要动态强制转换？它不需要，因为您将有虚拟表。请您删除所有强制转换的内容。所有这些强制转换都是错误的！您有没有删除的
new
，以及没有虚拟析构函数的多态类型，两者都是ca用一些代码来充实这个答案会有很大的帮助。尤其是
std:：variant
选项，因为它可能不是每个读者都能清楚地知道如何正确使用它和
std:：visit
。我把智能指针放在这里，它比手工管理指针要好。
~a（）override=default；
是无用的样板。用一些代码充实这个答案会有很大的帮助。尤其是
std:：variant
选项，因为可能不是每个读者都知道如何正确使用它和
std:：visit
。我把智能指针放在这里，它比手工管理指针要好。
~a（）override=default；
是无用的样板。
#include <vector>
#include <iostream>
#include <variant>

class A
{
public:
  void display()
  {
    std::cout << "Display from A\n";
  }
};

class B
{
public:
  void display()
  {
    std::cout << "Display from B\n";
  }
};

int main(void)
{   
    using variant_t = std::variant<A, B>; 
    std::vector<variant_t> v;

    v.emplace_back(A());
    v.emplace_back(B());

    for (auto &element: v) {
        std::visit([](auto &x) { x.display(); }, element);
    }
}

class can_display {
public:
  virtual void display() = 0;
  virtual ~can_display() = default;
};

class A : public can_display 
{
  void display() override
  {
    // display something
  }
};

class B : public can_display 
{
  void display() override
  {
    // display something two
  }
};

int main()
{
  A a;

  B b;

  std::vector<can_display *> displayables;

  displayables.push_back(&a);

  displayables.push_back(&b);

  for (can_display * displayable : displayables)
  {
    displayable->display();
  }
}

template <typename T>
class can_display_impl {
  T * wrapped;
public:
  can_display_impl(T * wrapped) : wrapped(wrapped) {}
  void display() override { wrapped->display(); }
}

template <typename T>
std::unique_ptr<can_display> make_can_display(T & wrapped) {
  return std::make_unique<can_display_impl<T>>(&wrapped);
}

int main()
{
  A a;

  B b;

  std::vector<std::unique_ptr<can_display>> displayables;

  displayables.emplace_back(make_can_display(a));

  displayables.emplace_back(make_can_display(b));

  for (auto & displayable : displayables)
  {
    displayable->display();
  }
}