Question

我有一个名为Ship()的课程，它看起来像这样

class Ship()
{
public:
    vector<Weapon*> Weapon
    void AddWeapon(Weapon*)
}

void MyShip::AddWeapon(Weapon*)
{
    Weapons.pushback(Weapon)
}

Weapon类是一个抽象基类，必须从游戏中的每种武器中派生出来。其中一个名为Lazer

所以在我的代码中，我可以这样做：

int main()
{
    Ship MyShip;
    Lazer MyLazer;
    MyShip.AddWeapon(&MyLazer)
}

如何确保Weapons中向量指向的对象不会超出范围？我相信答案是在heap上制作实例，但我不知道。

Answer 1

这样的事情是最安全的：

#include <memory>
#include <vector>

struct Weapon {

    virtual ~Weapon() = default;
};

struct Lazer : Weapon {

};

class Ship
{
public:
    void AddWeapon(std::unique_ptr<Weapon> weapon);

private:
    std::vector<std::unique_ptr<Weapon>> _weapons;
};

void Ship::AddWeapon(std::unique_ptr<Weapon> weapon)
{
    _weapons.push_back(std::move(weapon));
}

// test

using namespace std;

int main(){
    auto ship = std::make_unique<Ship>();
    ship->AddWeapon(std::make_unique<Lazer>());

    return 0;
}

Answer 2

您应该使用＆＃34; new＆＃34;从堆创建武器实例，然后您可以决定何时删除您创建的实例。您还应该使用父类指针指向您的实例，这称为动态绑定。

int main()
{
    Ship MyShip();
    Weapon * p = new MyLazer();
    MyShip.AddWeapon(p)
}

Makng实例＆＃34; Heap＆＃34;

2 个答案: