函数重载并根据相同的输入返回不同的数据类型 我对C++还很陌生，我知道我正在做的这个项目不应该因为C++复杂而被编程，但是我认为这是学习C++的一些进路的好方法。我有一个基类指针的存储向量，它是指向多个不同派生类对象的指针。但是，我想找到一种最简单的方法，以使用派生类成员函数的方式强制转换基类指针（从技术上讲，它们是被切掉的，但是我在用派生类对象推回向量时使用了“new”关键字）。我和其他计算机科学的同事谈过，他们说这是做我想做的事情（继承和多态性）的最好方法。我在基类中有两个变量，它们决定指针指向的派生类的类型，所以我很容易弄清楚什么是什么，但是有没有可能找到一种方法将这些基类指针永久转换为它们自己的派生类呢？或者至少创建一个函数来快速转换每个指针（B2D）？有人告诉我可以使用函数重载。下面是一个我认为会发生的事情的例子（但可能是非常错误的） 类基{ 公众： std:：string getdTypeName；//变量的getter函数 私人： std:：stringdtypename； } d1类：公共基地{ 公众： //d1专有功能 dTypeName=derived1； } d2类：公共基地{ 公众： //d2专用功能 dTypeName=derived2； } d3类：公共基地{ 公众： //d3专用功能 dTypeName=derived3； } std:：向量存储；//这些是随机生成的，但现在就可以了 存储。推回（新d1）； 存储。推回（新d2）； 存储。推回（新d3）； if（存储[0]->getdTypeName（）==“derived1”）{ //静态或动态转换为d1对象，或指针？或其他？ } if（存储[0]->getdTypeName（）==“derived2”）{ //与上面相同，但使用d2对象/指针 } 如果（存储[0]->getdTypeName（）=“derived3”{ //与上面的d3对象/指针相同 //是否对每个索引执行上述操作？ }

知道我试图编程的内容的范围，我认为如果我必须检查每个索引的次数与检查派生类的次数一样多，那也没什么大不了的，但是有没有一种更有效的方法来执行B2D转换？每次我想执行B2D转换时，我是否都必须执行此方法？如果是的话，是否有可能将其压缩为一个函数？我是这么想的仔细想想，我遇到的一个问题是返回类型，因为无论dTypeName是什么，都决定了数据类型。我是否需要重载它三次，但根据if语句的结果返回不同的数据类型？提前感谢！

使用虚拟函数可以实现您想要的

class Base
{
public:
  virtual void doSomething()
  {
    // base implementation
  }
};

class D1 : public Base
{
public:

  void doSomething() override
  {
    // D1 implmentation
  }
};

class D2 : public Base
{
public:

  void doSomething() override
  {
    // D2 implmentation
  }
};

在main（）中，现在可以对基指针调用doSomething，而不用担心它们的类型

---

如果您仍然希望将强制转换作为一种学习练习，可以使用dynamic_cast，如果类型与实际存储的指针不匹配，它将返回null ptr。

对于您的方法，您可以使用

dynamic_cast

struct base
{
    virtual ~base() = default;
};

struct d1 : base {};
struct d2 : base {};
struct d3 : base {};

void foo(base& b)
{
    if (auto* d = dynamic_cast<d1*>(&b)) {
         std::cout << "derived 1\n";
    } else if (auto* d = dynamic_cast<d2*>(&b)) {
         std::cout << "derived 2\n";
    } else if (auto* d = dynamic_cast<d3*>(&b)) {
         std::cout << "derived 3\n";
    }
}

int main()
{
    d1 o1;
    d2 o2;
    d3 o3;
    std::vector<base*> bases{&o1, &o2, &o3};

    for (auto* b : bases) {
        foo(*b);
    }
}

struct base
{
virtual~base（）=默认值；
};
结构d1:base{}；
结构d2:base{}；
结构d3:base{}；
富奥酒店（基本食宿）
{
if（自动*d=动态_转换（&b））{
std：：难道你根本不需要向下转换吗？请使用polymorphous with
virtual
方法。特别是“假装你在和一个忙碌的同事说话”和“拼写、语法和标点符号很重要！”
struct base
{
    virtual ~base() = default;
    virtual void foo() = 0;
};

struct d1 : base { void foo() override { std::cout << "derived 1\n";} };
struct d2 : base { void foo() override { std::cout << "derived 2\n";} };
struct d3 : base { void foo() override { std::cout << "derived 3\n";} };

int main()
{
    d1 o1;
    d2 o2;
    d3 o3;
    std::vector<base*> bases{&o1, &o2, &o3};

    for (auto* b : bases) {
        b->foo();
    }
}