c++ - 原型(prototype)模式C++中的智能指针

我目前正在查看我在github上找到的一些代码，但是我对代码的某些部分及其功能感到困惑。

下面的行是什么意思？键是bulletType，值是智能指针，什么是hash<int>？

unordered_map<BulletType, unique_ptr<Bullet>, hash<int> > m_Bullets

下面的代码做什么？

它是否创建一个新的GoodBullet对象，并使用*this作为构造函数的参数返回地址？

return std::make_unique<GoodBullet>(*this)

主要代码:

#include <iostream>
#include <unordered_map>
#include <string>
#include <memory>
using namespace std;


/** Bullet is the base Prototype */
class Bullet
{
protected:
    string _bulletName;
    float _speed;
    float _firePower;
    float _damagePower;
    float _direction;

public:
    Bullet(){}
    Bullet(string bulletName, float speed, float firePower, float damagePower)
    : _bulletName(bulletName), _speed(speed), _firePower(firePower), _damagePower(damagePower)
    {}
    virtual ~Bullet() {}
    virtual unique_ptr<Bullet> clone() = 0;
    void fire(float direction)
    {
        _direction = direction;

        cout << "Name        : " << _bulletName << endl
             << "Speed       : " << _speed << endl
             << "FirePower   : " << _firePower << endl
             << "DamagePower : " << _damagePower << endl
             << "Direction   : " << _direction << endl << endl;
    }
};

/** SimpleBullet is a Concrete Prototype */
class SimpleBullet : public Bullet
{

public:
    SimpleBullet(string bulletName, float speed, float firePower, float damagePower) :
    Bullet(bulletName, speed, firePower, damagePower)
    {
    }

    unique_ptr<Bullet> clone() override
    {
        return make_unique<SimpleBullet>(*this);
    }
};

/** GoodBullet is the Concrete Prototype */
class GoodBullet : public Bullet
{

public:
    GoodBullet(string bulletName, float speed, float firePower, float damagePower)
    : Bullet(bulletName, speed, firePower, damagePower)
    {
    }

    unique_ptr<Bullet> clone() override
    {
        return std::make_unique<GoodBullet>(*this);
    }
};


/** Opaque Bullet type, avoids exposing concrete implementations */
enum BulletType
{
    SIMPLE,
    GOOD
};

/** BulletFactory is the client */
class BulletFactory
{
private:
    unordered_map<BulletType, unique_ptr<Bullet>, hash<int> > m_Bullets;

public:
    BulletFactory()
    {
        m_Bullets[SIMPLE] = make_unique<SimpleBullet>("Simple Bullet", 50, 75, 75);
        m_Bullets[GOOD]   = make_unique<GoodBullet>("Good Bullet", 75, 100, 100);
    }

    unique_ptr<Bullet> createBullet(BulletType BulletType)
    {
        return m_Bullets[BulletType]->clone();
    }
};

int main()
{
    BulletFactory bulletFactory;

    auto Bullet = bulletFactory.createBullet(SIMPLE);
    Bullet->fire(90);

    Bullet = bulletFactory.createBullet(GOOD);
    Bullet->fire(100);
}

最佳答案

hash<int>是用于使无序映射(实际上是哈希映射)的键变为可查询(并与之比较)的键的函数。
return std::make_unique<GoodBullet>(*this):

构造一个GoodBullet(在这种情况下，使用copy-c'tor)

将其包装在std::unique_ptr<GoodBullet>和

中

返回它。

std::unique_ptr是一个智能指针，它不允许复制它，因此您知道从clone()获得的实例是唯一的实例(除非您从预先存在的原始指针构造了unique_ptr， t)。您只能将其“移动”到另一个unique_ptr，并且当超出范围时，它也将破坏包装的GoodBullet。