5

我正在尝试创建一个类似于大多数操作系统中使用的文件夹/文件系统。基本上我已经知道我应该使用三个类；File, Folder, 和一个公共基类。Common让我们为了创造力而称它为。以下是我认为这三个标题的样子：

常见的.h

class Common {
    string m_name; // all files and folders have a name
    Folder* m_parent; // all files and folders can have a parent

public:
    virtual void open() = 0; // executed when folder or file is opened by user
    virtual void draw() const; // all files and folders can be printed
    virtual void setParent(Folder* parent);
    virtual Folder* getParent() const;
};

文件夹.h

class Folder : public Common {
    vector<Common*> m_children; // folders can contain other files and folders
                                // whereas files cannot

public:
    virtual void open(); // folder opens; basically shows the content
    virtual void draw() const; // folder draws differently
};

文件.h

class File : public Common {
    // not really "files", they just call a function when opened
    funcptr m_openAction;

public:
    virtual void open(); // calls m_openAction() when opened
};

如您所见，问题在于我的基类Common应该能够知道它的子类Folder，这是不好的行为，不应该这样做（至少根据我的老师）。这使我无法像我计划的那样对系统进行编码。

这样的系统应该如何设计？

4

2 回答 2

8

您现有的设计不需要“Common知道它的子类Folder”。它只需要Common标头声明有一些这样的 类Folder：

class Folder; // Forward declaration

class Common {
    string m_name; // all files and folders have a name
    Folder* m_parent; // all files and folders can have a parent

public:
    virtual ~Common(); // Don't forget virtual destructor!
    virtual void open() = 0; // executed when folder or file is opened by user
    virtual void draw() const; // all files and folders can be printed
    virtual void setParent(Folder* parent);
    virtual Folder* getParent() const;
};

这里没有依赖循环。

如果出于某种学术原因，您必须有一个甚至没有 提及任何子类的基类，那么您可以像这样制作多态基类：

class Node {
    string m_name; // all files and folders have a name
    Node* m_parent; // all files and folders can have a parent

public:
    virtual ~Node(); // Don't forget virtual destructor!
    virtual void open() = 0; // executed when folder or file is opened by user
    virtual void draw() const; // all files and folders can be printed
    virtual void setParent(Node* parent);
    virtual Node* getParent() const;
};

然而，使用这种设计，该setParent(Node* parent)方法必须包括运行时检查Node *参数parent实际上是 a Folder *，使用例如

Folder *pf = dynamic_cast<Folder *>(parent);

在这种情况下，它还需要一个非 void 返回类型来指示成功或失败。这与仅仅发表声明相比是曲折的class Folder。

继续解决 OP 的后续问题。

在 Common's 里面setParent()我必须调用 Folder's m_children; 这会导致错误。即使我在 common.cpp 中包含了 folder.h，我也无法访问文件夹的私有成员。有任何想法吗？:'

我前面的回答仅限于向您展示“使您无法像您计划的那样对系统进行编码”实际上并没有。

您现在看到的问题是，将某个文件夹设置f为某个节点的父级n并不是对节点（文件或文件夹）的独立操作。如果同时成为 的子级之一，则f只能有效地成为 的父级。因此，在 您希望添加的设置的同时；但节点无法访问。nnfn.setParent(parent)n.mParent == parentnparent->m_childrenm_childrenn

这个问题对你的设计来说是一个沉重的提示。如果设置父项和添加子项必须始终一起发生，那么它们实际上是相同的操作——设置父项添加子项——只是调用方式不同：从父项或子项调用。如果有提供的理由，那么Common提供setParent(Folder *)同样有充分的理由，他们必须做同样的事情。FolderaddChild(Common *)

这是否表明，比如说，static void Common::link(Folder * parent, Common * child) 可能更好地公开替换它们？可能是这样; 但是您从 开始 Common::setParent(Folder *)，这是合理的；所以与之匹配Folder::addChild(Common *)也是合理的，然后我们可以通过相互调用来让它们做同样的事情。

pCommon->setParent(pFolder)还请考虑，既然
等价于pFolder->addChild(pCommon)，您还需要 从其父节点中删除节点的方法；因为在您可以有效地将节点添加到父节点之前，您必须将其从其现有父节点中删除（如果有）。而且这个操作很可能对客户端代码有好处；so Folder::removeChild(Common *)也是 Folder界面的自然补充。

Folder::addChild(Common * pnode)并且Folder::removeChild(Common * pnode)是您管理私有成员所缺少的接口Folder::m_children。

接下来，考虑这些方法中的每一个都必须确定pnode实际上是否是文件夹的子文件夹：您不能将子文件夹添加到已经是子文件夹的文件夹中，并且不能删除不是文件夹的子文件夹一。所以Folder::find(Common * pnode)也将是有用的 - 至少对实现（私有），并且似乎也对客户端代码（公共）：你可以决定。

然后，考虑Folder::find(Common * pnode)需要另一种方法：bool Common::operator==(Common const & other). 我们只是说如果节点具有相同的名称，则它们是相等的。

Common::clearParent()也浮现在脑海中，但我将把它放在一边。

这些想法足以满足以下实现，这是不完整的、次优的和不切实际的，但展示了如何连接我们刚刚确定的点，以通过仍然阻止您的成员访问障碍。这是不切实际的，因为它忽略了动态对象的所有权的整个问题，这些动态对象被假定由其方法的Folder *和Common *参数解决。您可以自己处理（并且您可能希望调查 std::shared_ptr和 std::unique_ptr，即使这些设施比您应该在本项目中使用的更先进）。

常见的.h

#ifndef COMMON_H
#define COMMON_H

#include <string>

#include <iostream>

class Folder;

class Common {
    std::string m_name;
    Folder* m_parent;

public:
    explicit Common(std::string const & name)
    : m_name(name),m_parent(nullptr){}
    virtual ~Common(){};
    virtual void open() { /*Whatever*/}
    virtual void draw() const {/*Whatever*/}
    virtual Folder* getParent() const { return m_parent; };
    virtual void setParent(Folder* parent);
    bool operator==(Common const & other) const {
        return m_name == other.m_name;
    }
    bool operator!=(Common const & other) const {
        return !(*this  == other);
    }
#if 1 // Testing
    std::string const & name() const {
        return m_name;
    }
    std::string parent() const;

    virtual void list() const {
        std::cout << name() << " (in " << parent() << ')' << std::endl ;
    }
#endif
};

#endif // EOF

文件夹.h

#ifndef FOLDER_H
#define FOLDER_H

#include "common.h"
#include <vector>

class Folder : public Common {
    std::vector<Common *> m_children;

    std::vector<Common *>::iterator find(Common const * child) {
        auto i = m_children.begin();
        for (   ;i != m_children.end() && **i != *child; ++i) {}
        return i;
    }

public:
    explicit Folder(std::string const & name)
    : Common(name){}
    virtual void open(){/*Whatever*/}
    virtual void draw() const {/*Whatever*/}
    void addChild(Common * child) {
        auto par = child->getParent();
        if (par && par != this) {
            par->removeChild(child);
        }
        if (find(child) == m_children.end()) {
            m_children.push_back(child);
            m_children.back()->setParent(this);
        }
    }
    void removeChild(Common const * child) {
        auto where = find(child);
        if (where != m_children.end()) {
            m_children.erase(where);
        }
    }
#if 1 // Testing
    void list() const {
        std::cout << name() << " {" << std::endl;
        for (Common const * child : m_children) {
            child->list();
        }
        std::cout << '}' << std::endl;
    }
#endif
};

#endif //EOF

文件.h

#ifndef FILE_H
#define FILE_H

#include "common.h"

class File : public Common {
    // Whatever
public:
    explicit File(std::string const & name)
    : Common(name){}
    virtual void open(){/*Whatever*/};

};

#endif // EOF

常见的.cpp

#include "common.h"
#include "folder.h"

void Common::setParent(Folder* parent) {
    auto par = getParent();
    if (par && par != parent) {
        par->removeChild(this);
    }
    m_parent = parent;
    m_parent->addChild(this);
}

#if 1 // Testing
std::string Common::parent() const {
    return m_parent ? m_parent->name() : "<null>";
}
#endif

一个测试程序：

#include "common.h"
#include "folder.h"
#include "file.h"

int main()
{
    Folder *fo0 = new Folder("folder0");
    File * fi0 = new File("file0");
    File * fi1 = new File("file1");
    fo0->addChild(fi0);
    fi1->setParent(fo0);
    fo0->addChild(fi0);  // Duplicate
    fi1->setParent(fo0); // Duplicate
    // There are now 2 files in folder fo0
    fo0->list();
    Folder *fo1 = new Folder("folder1");
    fo1->addChild(fi1);
    fi0->setParent(fo1);
    fo1->addChild(fi1); // Duplicate
    fi0->setParent(fo1); // Duplicate
    // There are now 0 files in folder fo0
    // There are now 2 files in folder fo1
    fo0->list();
    fo1->list();
    delete fo0;
    delete fo1;
    delete fi0;
    delete fi1;
    return 0;
}
于 2013-06-10T19:40:37.857 回答
0

您不能将文件夹放在 common 中并在文件夹中继承 common；这是一个循环冗余错误。

该系统可以设计为只有两个类：文件和文件夹，但如果你想进行概括，请从公共中删除文件夹。

于 2013-06-10T18:23:27.050 回答