在C+中使用多态性优于继承的实际优势+； P>使用C++中的多态性，而不仅仅是继承，这是什么优势，因为在我看来，我不能用多态来实现，有些东西我不能仅仅继承。在这两种方式中，我都可以使用虚拟函数。是否存在这样的情况，多态性可以通过仅仅使用继承来实现无法实现的事情

这两个例子（第一个多态性，第二个单纯的遗传）让我得到了相同的结果，所以我想知道，多重多态性还能为我提供什么，这是通过正常遗传无法实现的

多态代码：

#include <iostream>
using namespace std;
class Kryptonians
{
public:
    void setPower(int p) {power = p;}
    void gotHit(int h){power -=h;}
    virtual void displayPower(){std::cout << "power is: " << power << "\n";}

protected:
    int power;
};

class Supergirl: public Kryptonians
{
public:
   void displayPower(){
       std::cout << "Supergirl's power is: " << power << "\n";}
};

class Superman: public Kryptonians
{
public:
    void displayPower(){
        std::cout << "Superman's power is: " << power << "\n";}
};

int main()
{
    Supergirl sup;
    Superman super;
    Kryptonians *supergirl = &sup;
    Kryptonians *superman = &super;

    supergirl->setPower(100);
    supergirl->displayPower();

    superman->setPower(100);
    superman->gotHit(50);
    superman->displayPower();
    supergirl->displayPower();
}

#包括
使用名称空间std；
氪类
{
公众：
void setPower（int p）{power=p；}
void gotHit（inth）{power-=h；}
虚拟void displayPower（）{std:：cout多态性

在计算机科学中，多态性是一种编程语言特性
允许以统一的方式处理不同数据类型的值
态度

例如：

void foo(bar& b) {
   b.do_something();
};

struct bar {
    virtual void do_something() = 0;
    virtual ~bar(){}
};

struct foobar1 : bar {
    virtual void do_something() override {
        std::cout << "muh";
    }
};

struct foobar2 : bar {
    virtual void do_something() override {
        std::cout << "meh";
    }
};

将不同类型的对象视为同一类型称为多态性。
b
可以是任何类型，只要它继承了
bar

继承

继承是面向对象编程中允许
对象来支持由前类型定义的操作，而无需
提供自己的定义。它是
面向对象编程中的多态性

例如：

void foo(bar& b) {
   b.do_something();
};

struct bar {
    virtual void do_something() = 0;
    virtual ~bar(){}
};

struct foobar1 : bar {
    virtual void do_something() override {
        std::cout << "muh";
    }
};

struct foobar2 : bar {
    virtual void do_something() override {
        std::cout << "meh";
    }
};

结构栏{
虚空do_something（）=0；
虚拟~bar（）{}
};
结构foobar1:bar{
虚拟void do_something（）覆盖{
STD：至少在C++中，使用继承的主要原因是多态性，也有所谓的“实现继承”，但它是一个普遍的规则。
多态性的规范示例涉及一个虚拟函数，该函数在基类中声明并在派生类中实现：

class interface { 
public:
    virtual void foo() = 0;
};

class implementation : public interface { 
public:
    virtual void foo() override {
        // do something useful here
    }
};

在这种情况下，基类实际上根本没有实现
foo
，它只是声明了一个接口，因此任何使用该接口的代码都可以使用该基类的任何派生

实现继承主要适用于以下情况：您有许多派生类，这些派生类对相同的一般事物都有细微的变化，因此您可以在case类中实现公共行为，并且每个派生类只实现其与公共基础不同的区域

 C++中实现继承的一个非常有名的例子是<>代码>：ST:：迭代器< /C>。这是一个包含虚拟函数（没有多态性）的基类。。它的唯一目的是提供迭代器需要提供的一些
typedef
s。这些类型通常都是相关的，因此派生类通常可以将单个模板参数传递给基类，并获取所有必要的
typedef
s：

class my_iterator : public std::iterator<std::output_iterator_tag, void, void, void, void> {
    // ...
};

class my_迭代器：public std:：iterator{
// ...
};

这样可以避免迭代器的实现者键入如下代码：
使用size\u type=std:：size\u t；
使用差异类型=标准：：ptr_差异；
使用值_type=T；
使用reference=T&；
使用指针=T*

它确实节省了一些打字——但不是全部，而且它所节省的几乎都是简单的锅炉板

但是，如上所述，这是不被接受的规则——事实上，
std:：iterator
已被正式弃用，因此它可能会从标准的未来版本中消失。
动态多态性是通过继承实现的。我不理解这个问题。如果您为同一个问题向我们展示两种解决方案，会更容易一些，一种使用（你所说的）多态性，一个使用（你所说的）继承。请为每种情况提供一个示例片段，这样我们可以更好地理解你想要比较的两种情况。（对我来说，它们是相同的）你的意思是？不。显然不是重读。我和其他人一样困惑。我知道多形性是通过遗传实现的。但是我问我还能对多态性做些什么仅仅通过遗传是不可能的。