您现有的设计不需要“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;
}