C++ 在C++；

我有两个班，一个扩展另一个。它们都有一个名为

doSomething（）

的方法，可以执行不同的操作。我希望能够有一个指针，我可以从

class A

切换到

class B

，并让其余的代码运行相同的代码，因为它们都有相同的方法名。这可能吗？这是正确的方法吗？另外，我对C++非常陌生，所以这可能只是个问题。

class A {
    void doSomething()
    {
        // does something
    }
};

class B: public A {
    void doSomething()
    {
        //does something else
    }
};


main()
{
    A *ptr = new A;
    B *bptr = new B;

    // a giant loop

    ptr->doSomething();


    if(condition) 
    {
        ptr = bptr;
    }
}

---

您试图实现的是多态性。在C++中，你需要为A和B定义一个公共的（可能是抽象的）基类C，使DOMEMETHORY A在A和B中重写它，并生成类型C*的指针。下面是关于这个主题的一个例子。

您试图实现的就是多态性。在C++中，你需要为A和B定义一个公共的（可能是抽象的）基类C，使DOMEMETHORY A在A和B中重写它，并生成类型C*的指针。这里有一个关于这个主题的例子。

我可以想出两种方法来实现这一点

如果您已经有了多态类型，那么您的方式很好（有一些小的变化）。（如果

B

是

A

，逻辑上）

但是如果你的类型没有那么紧密的联系呢？使用继承意味着类之间的关系非常严格（在本例中是-a）。a

B

真的是

a

对于具有相同命名函数但实际上类型不相似的类，这里有一种方法可以实现这一点

template <class T>
void do_f(T& obj)
{
   obj.f();
}

class D
{
public:
   void f() { /* something */ }
};

class E
{
public:
   void f() { /* something else entirely */ }
};

int main()
{
   // note, D and E have no relation
   D d;
   E e;

   // based on your condition
   do_f(d);
   do_f(e);
}

模板
无效do_f（T&obj）
{
obj.f（）；
}
D类
{
公众：
void f（）{/*某物*/}
};
E类
{
公众：
void f（）{/*完全其他的东西*/}
};
int main（）
{
//注意，D和E没有关系
D；
E；
//根据你的情况
杜夫（d）；
杜夫（e）；
}

我可以想出两种方法来实现这一点

如果您已经有了多态类型，那么您的方式很好（有一些小的变化）。（如果

B

是

A

，逻辑上）

但是如果你的类型没有那么紧密的联系呢？使用继承意味着类之间的关系非常严格（在本例中是-a）。a

B

真的是

a

对于具有相同命名函数但实际上类型不相似的类，这里有一种方法可以实现这一点

template <class T>
void do_f(T& obj)
{
   obj.f();
}

class D
{
public:
   void f() { /* something */ }
};

class E
{
public:
   void f() { /* something else entirely */ }
};

int main()
{
   // note, D and E have no relation
   D d;
   E e;

   // based on your condition
   do_f(d);
   do_f(e);
}

模板
无效do_f（T&obj）
{
obj.f（）；
}
D类
{
公众：
void f（）{/*某物*/}
};
E类
{
公众：
void f（）{/*完全其他的东西*/}
};
int main（）
{
//注意，D和E没有关系
D；
E；
//根据你的情况
杜夫（d）；
杜夫（e）；
}

基本上是这样，但您需要三个指针——一个用于每个对象，另一个用于保存“您正在使用的指针”。这将帮助您在关闭“您正在使用的那个”时避免内存泄漏。更好的问题是“为什么您认为您需要这个？”。您发布的代码有三个问题。首先，只有在使用了ptr之后，才能更改它。其次，如前所述，您可能会出现内存泄漏。共享指针支持多态行为，所以我会使用它们。第三，在C++中，你必须通过声明函数虚函数来请求这个行为。任何介绍性的C++文本或课程都会比我们在这里所做的更详细地涵盖多态性，可能会滥用多态性。多态性的一大优点是，您不必使用条件来确定在给定方法上调用哪个实现—类型决定它。@DavidV：正好相反：OP可以使用多态性来避免传播

if（条件）

基本上贯穿整个

巨循环，但您需要三个指针——每个对象一个指针，另一个指针用于保存“您正在使用的指针”。这将帮助您在关闭“您正在使用的那个”时避免内存泄漏。更好的问题是“为什么您认为您需要这个？”。您发布的代码有三个问题。首先，只有在使用了ptr之后，才能更改它。其次，如前所述，您可能会出现内存泄漏。共享指针支持多态行为，所以我会使用它们。第三，在C++中，你必须通过声明函数虚函数来请求这个行为。任何介绍性的C++文本或课程都会比我们在这里所做的更详细地涵盖多态性，可能会滥用多态性。多态性的一大优点是，您不必使用条件来确定在给定方法上调用哪个实现—类型决定它。@DavidV：正好相反：OP可以使用多态性来避免传播
if（条件）
贯穿整个
巨环
不，你没有。可能指向A或B的A*可以。你是对的，doSomething必须是虚拟的。@KateGregory你是对的，我没有意识到OP在B中继承了A，因为语法（他有
class B（）：public A（）
而不是
类别B:public A
。原始代码有很多问题-
}
在
}；
所属的位置；

具有

：：

内部类定义的函数体等。这些圆括号特别好。是的，对于伪代码我只是想了解一下，但是的，这似乎是解决方案ion。我对虚拟函数不是很熟悉，但这真的很有帮助，谢谢！不，你不知道。可能指向A或B的A*很好。doSomething必须是虚拟的这一点你是对的。@Kategory你是对的，我没有意识到OP在B中继承A是因为语法（他有

类B（）：public A（）

而不是

B类：公共A

。原始代码有很多问题-

}

在

}；

所属的位置；

，类内定义有
：：
的函数体等等。这些圆括号特别好。是的，对于伪代码，我只是想了解一下