blocks|key|1740215|text|这听起来像是访客模式的案例。您让访问者访问A的每个孩子。对于每一个孩子，它将再次访问所有的孩子，等等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1740216|当访问者遍历树时，您将收集每个节点的数据。例如，在这种情况下，如果需要，可以直接用XML收集数据。|1740217|访问者模式可以很好地处理异构数据类型，但是当一些节点也具有共同的结构时，就可以了。|1740218|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Visitor_pattern^0|L|1|6|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

This sounds like a case for the <a href="https://en.wikipedia.org/wiki/Visitor_pattern" rel="nofollow">Visitor pattern</a>. You let the Visitor visit each of the children of <code>A</code>. For each child, it'll again visit all children, and so on.

While the Visitor traverses the tree, you collect data about each node. You can, in this case, for example collect the data directly in XML if you want.

The Visitor pattern works well with heterogeneous data types, but it's OK when some of the nodes have common structure as well.

blocks|key|576686|text|访问者模式是一种更好的执行操作的方法，在这些操作中，所有父类和子类都应被接受为输入，行为由对象类型决定。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|576687|下面是供您参考的C%2B%2B实现：|576688|#include+<vector>
#include+<iostream>
using+namespace+std;

class+Visitor
{
++public:
++++virtual+void+visit(class+Node+*,+class+Common*)+=+0;
++++virtual+void+visit(class+CompositeNode+*,+Common*)+=+0;
};

class+Common
{
++++int+value;
++public:
++++Common(int+val)
++++{
++++++++value+=+val;
++++}
++++virtual+void+traverse()
++++{
++++++++cout+<<+value+<<+"+%7C+";
++++}

++++virtual+void+accept(Visitor+&,+Common*)+=+0;
};

class+Node:+public+Common
{
++public:
++++Node(int+val):+Common(val){}
+++++virtual+void+accept(Visitor+&v,+Common+*c)
++++{
++++++++v.visit(this,+c);
++++}
};

class+CompositeNode:+public+Common
{
++++vector+<+Common+*+>+children;
++public:
++++CompositeNode(int+val):+Common(val){}
++++void+add(Common+*ele)
++++{
++++++++children.push_back(ele);
++++}
+++++virtual+void+accept(Visitor+&v,+Common+*c)
++++{
++++++++v.visit(this,+c);
++++}
+++++virtual+void+traverse()
++++{
++++++++Common::traverse();
++++++++for+(int+i+=+0;+i+<+children.size();+i%2B%2B)
++++++++++children[i]->traverse();
++++}
};

class+AddVisitor:+public+Visitor
{
++public:
+++++virtual+void+visit(Node+*,+Common*)
++++{
++++}
+++++virtual+void+visit(CompositeNode+*node,+Common+*c)
++++{
++++++++node->add(c);
++++}
};

int+main()
{
++Common+*nodes[3];

++nodes[0]+=+new+CompositeNode(0);+//Consider+A
++nodes[1]+=+new+CompositeNode(1);+//Consider+B
++nodes[2]+=+new+CompositeNode(2);+//Consider+B

++AddVisitor+addVisitor;
++nodes[0]->accept(addVisitor,+nodes[1]);+//B
++nodes[0]->accept(addVisitor,+nodes[2]);+//B
++nodes[1]->accept(addVisitor,+new+Node(3));+//Consider+C
++nodes[1]->accept(addVisitor,+new+Node(4));+//Consider+C
++nodes[2]->accept(addVisitor,+new+Node(5));+//Consider+C
++nodes[2]->accept(addVisitor,+new+Node(6));+//Consider+C

++for+(int+i+=+0;+i+<+3;+i%2B%2B)
++{
++++cout<<"--------------------------------"<<endl;
++++nodes[i]->traverse();
++++cout<<endl;
++}
}|code-block|syntax|javascript|576689|输出|576690|--------------------------------
0+%7C+1+%7C+3+%7C+4+%7C+2+%7C+5+%7C+6+%7C
--------------------------------
1+%7C+3+%7C+4+%7C
--------------------------------
2+%7C+5+%7C+6+%7C|576691|entityMap^0|0|5|0|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Visitor pattern is a better way of performing operations that where all parent and child classes should be accepted as input and in which behavior is dictated by the object type.

Here's C++ Implementation for your reference:

<pre><code>#include &lt;vector&gt;
#include &lt;iostream&gt;
using namespace std;

class Visitor
{
 public:
 virtual void visit(class Node *, class Common*) = 0;
 virtual void visit(class CompositeNode *, Common*) = 0;
};

class Common
{
 int value;
 public:
 Common(int val)
 {
 value = val;
 }
 virtual void traverse()
 {
 cout &lt;&lt; value &lt;&lt; " | ";
 }

 virtual void accept(Visitor &amp;, Common*) = 0;
};

class Node: public Common
{
 public:
 Node(int val): Common(val){}
 virtual void accept(Visitor &amp;v, Common *c)
 {
 v.visit(this, c);
 }
};

class CompositeNode: public Common
{
 vector &lt; Common * &gt; children;
 public:
 CompositeNode(int val): Common(val){}
 void add(Common *ele)
 {
 children.push_back(ele);
 }
 virtual void accept(Visitor &amp;v, Common *c)
 {
 v.visit(this, c);
 }
 virtual void traverse()
 {
 Common::traverse();
 for (int i = 0; i &lt; children.size(); i++)
 children[i]-&gt;traverse();
 }
};

class AddVisitor: public Visitor
{
 public:
 virtual void visit(Node *, Common*)
 {
 }
 virtual void visit(CompositeNode *node, Common *c)
 {
 node-&gt;add(c);
 }
};

int main()
{
 Common *nodes[3];

 nodes[0] = new CompositeNode(0); //Consider A
 nodes[1] = new CompositeNode(1); //Consider B
 nodes[2] = new CompositeNode(2); //Consider B

 AddVisitor addVisitor;
 nodes[0]-&gt;accept(addVisitor, nodes[1]); //B
 nodes[0]-&gt;accept(addVisitor, nodes[2]); //B
 nodes[1]-&gt;accept(addVisitor, new Node(3)); //Consider C
 nodes[1]-&gt;accept(addVisitor, new Node(4)); //Consider C
 nodes[2]-&gt;accept(addVisitor, new Node(5)); //Consider C
 nodes[2]-&gt;accept(addVisitor, new Node(6)); //Consider C

 for (int i = 0; i &lt; 3; i++)
 {
 cout&lt;&lt;"--------------------------------"&lt;&lt;endl;
 nodes[i]-&gt;traverse();
 cout&lt;&lt;endl;
 }
}
</code></pre>

Output

<pre><code>--------------------------------
0 | 1 | 3 | 4 | 2 | 5 | 6 |
--------------------------------
1 | 3 | 4 |
--------------------------------
2 | 5 | 6 |
</code></pre>

I am stuck with the design problem. I could not come up with any good solution. Here is the problem statement.

I have set of devices, each of these devices has some common properties and behavior. Each device may contain 1 or more than one other type of devices connected to it. For example : If there are 4 set of devices A,B,C,D and A being the root of all the devices.

<pre><code>A will have one or many B devices.
B will have one or many C devices.
C will have one or many D devices.
</code></pre>

All these different set of devices have some common properties while some are exclusive to themselves. 

<code>I have to create a report which will read the data from these objects and read it to file. Report is in XML format and will depict hierarchy of whole system.</code>

How could I approach this problem ? Any suggestion comment would be of great help.

Designing Classes: Each class encapsulate object of other related class

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我被设计问题困住了。我想不出任何好的解决办法。这是问题陈述。我有一组设备，每个设备都有一些共同的属性和行为。每个设备可以包含一个或多个连接到它的其他类型的设备。例如:如果有4组设备A、B、C、D和A是所有设备的根。A will have one or many B devices.B will have one or ...

问设计类:每个类封装其他相关类的对象。
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问设计类:每个类封装其他相关类的对象。EN