（初学者）C++；关于继承 我试图在C++中解决继承问题，并想知道如何正确地进行。p>

我开设了3个课程： -敌人（有成员数据：智力伤害、智力生命和智力等级） -狼 -忍受

我继承遗产的方式是：狼是敌人，熊是敌人。换句话说，狼和熊都是从敌人那里继承的

我想设置我的程序，这样当我创建一个新的敌人时，就像这样：

Enemy anEnemy; 

然后在敌人：：敌人（）构造函数中，它将随机决定敌人是狼还是熊

如何处理这个问题？我知道我必须在敌方：：敌方（）构造函数中生成一个随机数，并根据随机数的结果将敌人变成熊或狼。但我就是不知道如何把敌人变成狼或熊

---

任何帮助都将不胜感激。谢谢

要在运行时随机决定类型，那么为了类型安全，实际上必须使用动态分配，例如

Enemy* p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then:
delete p_enemy;

其中，

random\u

是一个类似

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

但是，您会发现，在许多/大多数情况下，手动

删除
是很难正确的。因此，通过使用智能指针（如
std:：unique_ptr
和
std:：shared_ptr
）实现自动化是很常见的。然后，使用代码可能如下所示：

unique_ptr<Enemy> p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then it auto-deletes.

唯一敌人=随机敌人（）；
//在这里使用p_敌人，例如p_敌人->制造噪音（），然后它会自动删除。

函数是这样的

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

自动随机
->独特的
{
返回唯一\u ptr(
我的随机数（）>0.5？新狼：新熊
);
}
要在运行时随机决定类型，那么为了类型安全，实际上必须使用动态分配，例如

Enemy* p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then:
delete p_enemy;

其中，
random\u
是一个类似

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

但是，您会发现，在许多/大多数情况下，手动
删除
是很难正确的。因此，通过使用智能指针（如
std:：unique_ptr
和
std:：shared_ptr
）实现自动化是很常见的。然后，使用代码可能如下所示：

unique_ptr<Enemy> p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then it auto-deletes.

唯一敌人=随机敌人（）；
//在这里使用p_敌人，例如p_敌人->制造噪音（），然后它会自动删除。

函数是这样的

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

自动随机
->独特的
{
返回唯一\u ptr(
我的随机数（）>0.5？新狼：新熊
);
}
要在运行时随机决定类型，那么为了类型安全，实际上必须使用动态分配，例如

Enemy* p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then:
delete p_enemy;

其中，
random\u
是一个类似

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

但是，您会发现，在许多/大多数情况下，手动
删除
是很难正确的。因此，通过使用智能指针（如
std:：unique_ptr
和
std:：shared_ptr
）实现自动化是很常见的。然后，使用代码可能如下所示：

unique_ptr<Enemy> p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then it auto-deletes.

唯一敌人=随机敌人（）；
//在这里使用p_敌人，例如p_敌人->制造噪音（），然后它会自动删除。

函数是这样的

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

自动随机
->独特的
{
返回唯一\u ptr(
我的随机数（）>0.5？新狼：新熊
);
}
要在运行时随机决定类型，那么为了类型安全，实际上必须使用动态分配，例如

Enemy* p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then:
delete p_enemy;

其中，
random\u
是一个类似

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

但是，您会发现，在许多/大多数情况下，手动
删除
是很难正确的。因此，通过使用智能指针（如
std:：unique_ptr
和
std:：shared_ptr
）实现自动化是很常见的。然后，使用代码可能如下所示：

unique_ptr<Enemy> p_enemy = random_enemy();

// Use p_enemy here, e.g. p_enemy->make_noises(), then it auto-deletes.

唯一敌人=随机敌人（）；
//在这里使用p_敌人，例如p_敌人->制造噪音（），然后它会自动删除。

函数是这样的

auto random_enemy()
    -> Enemy*
{
    return (my_random_number() > 0.5? new Wolf : new Bear);
}

auto random_enemy()
    -> unique_ptr<Enemy>
{
    return unique_ptr<Enemy>(
        my_random_number() > 0.5? new Wolf : new Bear
        );
}

自动随机
->独特的
{
返回唯一\u ptr(
我的随机数（）>0.5？新狼：新熊
);
}
您现在有两个问题：

首先，多态性（查找）基于引用或指针，而不是值。
因此，当您创建Ennemy（可能是“随机”的熊或狼）时，您不能为其保留值类型的变量，因为类型并不总是相同的

Ennemy my_ennemy = (Bear or Wolf); // This is impossible.

本质上，熊和狼不是同一类型，甚至大小也不相同，因此它们无法放入分配的九位字节大小的内存中

你需要这样的东西：

Ennemy *my_ennemy = new Bear(); // OR
Bear someExistingBear;
Ennemy *my_ennemy = &someExistingBear; // Or even
std::unique_ptr<Ennemy> my_ennemy(new Bear());

您现在有两个问题：

首先，多态性（查找）基于引用或指针，而不是值。
因此，当您创建Ennemy（可能是“随机”的熊或狼）时，您不能为其保留值类型的变量，因为类型并不总是相同的

Ennemy my_ennemy = (Bear or Wolf); // This is impossible.

本质上，熊和狼不是同一类型，甚至大小也不相同，因此它们无法放入分配的九位字节大小的内存中

你需要这样的东西：

Ennemy *my_ennemy = new Bear(); // OR
Bear someExistingBear;
Ennemy *my_ennemy = &someExistingBear; // Or even
std::unique_ptr<Ennemy> my_ennemy(new Bear());

您现在有两个问题：

首先，多态性（查找）基于引用或指针，而不是值。
因此，当您创建Ennemy（可能是“随机”的熊或狼）时，您不能为其保留值类型的变量，因为类型并不总是相同的

Ennemy my_ennemy = (Bear or Wolf); // This is impossible.

本质上，熊和狼不是同一类型，甚至大小也不相同，因此它们无法放入分配的九位字节大小的内存中

你需要这样的东西：

Ennemy *my_ennemy = new Bear(); // OR
Bear someExistingBear;
Ennemy *my_ennemy = &someExistingBear; // Or even
std::unique_ptr<Ennemy> my_ennemy(new Bear());

您现在有两个问题：

首先，多态性（查找）基于引用或指针，而不是值。
因此，当您创建Ennemy（可能是“随机”的熊或狼）时，您不能为其保留值类型的变量，因为类型并不总是相同的

Ennemy my_ennemy = (Bear or Wolf); // This is impossible.

从本质上说，熊和狼不是同一种类型，甚至大小也不一样，所以它们不能放在allo中