使用现有类设计实现功能的问题

Question

我目前已经开始了我的编程课程的学期项目——对完全自动驾驶模拟器进行编程。所有汽车均通过人工智能驾驶，地图打印在控制台上。

第一张表要求我们创建几个基本类：FCCompact（汽车）、Scanner（AI）、ID（地形）和 World（地图）。

扫描仪目前在我的 FCCompact 类中作为“HAS-A”实现，如下所示：

// FCCompact.h
class FCCompact
{
private:
    struct fImpl;
    fImpl *fImpl_;
/* ... */

// FCCompact.cpp
struct fImpl
{
    Scanner scanner_;
    /* ... */
};

所讨论的扫描仪功能

const ID& scanForID( int fovNumber,            // How far it can see
                     FCCompact::Direction dir, // Direction car is facing
                     const Location& loc);     // Location of car

到目前为止都很好。然而，整个地图位于一个容器 vector< 中。双端队列>(1)在类World中；我不知道如何访问它。

目前贴出的功能都是老师给我们的，所以按照给定的参数应该可以实现。我只是不知道该怎么做。

我的第一个想法是调用 World::getID(Location &)，但它不是静态的。将其设为静态后，它无法再访问非静态成员（呃，我忘了这一点）。我还制作了一个调用非静态函数的静态函数；同样的问题（双废话）。

然后我扔掉了老师的指南，只是简单地传入了整个 World 对象，但这也没有真正起作用。

我能做些什么？

请记住，这在技术上是一项作业，我不需要完整的、合格的答案，甚至可以让我完整地实现我想做的事情。我想从这个项目中学到尽可能多的东西，所以请为我指明正确的方向。

(1)：容器类型的选择很奇怪？我认为如果世界被打印在控制台上，那么使用向量快速访问每一行将是有益的，因为不会插入或删除队列，并且访问时间非常短。

另一方面，双端队列可以方便地访问范围，这是有利的，因为我会经常更改相邻的列（沿 x 或 y 轴行驶的汽车）。这个选择来得并不快。我仍然在这个、列表还是简单向量之间左右为难。

类

类 世界

class ID;
class World
{
    typedef std::pair<int, int> Location;

private:    
// vector<deque<ID> > map
// int mapHeight, mapWidth
// string mapName
    struct wImpl;
    wImpl *pimpl_;

public:
    World();
    ~World();

    void create(const std::string& name = "FC-City");

    int getHeight() const;
    int getWidth() const;

    ID getID(const Location& loc);

    friend std::ostream& operator<<(std::ostream& os, World& world)
    {
        return os;
    }

private:
    void loadMap(std::string name = "FC-City");

private:
    World(const World& other);
    World& operator=(const World& other);
};

类 扫描仪

class ID;
class Scanner
{
    typedef std::pair<int, int> Location;

public:
    Scanner();
    ~Scanner();

    const ID& scanForID( int fovNumber, 
                         FCCompact::Direction dir, 
                         const Location& loc);

private:
    Scanner(const Scanner& other);
    Scanner& operator==(const Scanner& other);
};

类 FCCompact

class ID;
class FCCompact
{
    typedef std::pair<int, int> Location;

public:
    enum Direction
    {
        N, E, S, W, 
        NA = -1
    };

private:
// Scanner scanner
// Location loc
// Direction dir
// ID id
    struct    FCCImpl;
    FCCImpl  *pimpl_;

public:
    FCCompact( const ID& id,
               const Location& loc,
               const Direction& dir);

    FCCompact( const char ch,
               const Location& loc,
               const Direction& dir);

    const ID& getID()  const;
    Location  getLoc() const;
    Direction getDir() const;
    void      setDir( Direction& dir );

    void step();
    void hide();
    void show();
};

类 ID

class ID
{
public:
    enum Trait
    {
        Traversable,
        NotTraversable,
        Mobile,
        Undef
    };

private:
    Trait trait_;
    char appearance_;

public:
    ID( char outputChar, Trait trait )
        : appearance_(outputChar), trait_(trait)
    { }

    ID( char outputChar )
        : appearance_(outputChar), trait_(Trait::Undef)
    { }

    char getToken()  const { return appearance_; }
    Trait getTrait() const { return trait_; }

    void setTrait(Trait trait) { trait_ = trait; }
};

Answer 1

Scanner 应该有一个接受 World 引用的构造函数；存储一个指向该参数的指针，以便稍后当您需要一个世界时，您就拥有了一个。

不要使用单例，他们很蠢。您可以使用全局，但这里确实没有必要。 Scanner 需要一个 World 来操作，因此您可以使用一个 World 来构造它来操作：

struct bar;

struct foo
{
    // foo cannot operate without a bar,
    // therefore it needs to be supplied with
    // one to be able to construct
    foo(const bar& pBar) :
    mBar(&pBar)
    {}

    void i_need_bar()
    {
        mBar->use_bar();
    }

    bar* mBar;
};

Answer 2

听起来您想要类 World 的单例模式。

class World {
public:
  static World* getWorld();

private:
  static World* _singleton;
};

您可以从构造函数和/或 create() 初始化 _singleton。如果您愿意，getWorld() 可以返回引用（或在失败时抛出异常）。由你来思考：如果有人尝试创造多个世界怎么办？您应该在程序结束时清理 World::_singleton 吗？