让我们假设我们有一个名为Node的类,该类具有一个称为sequence和id的成员。我们希望以许多不同的方式打印节点的顺序。我们没有将打印功能直接添加到Node类中,而是将它们放在一个单独的类NodePrinter中。无论如何,每个节点都需要有一个“工作”的NodePrinter。
这意味着:
NodePrinter * printer
成员new NodePrinter
我现在的想法是创建一个
BaseNode
并将NodePrinter
移到该代码中。它只有一个构造函数,该构造函数将Node
作为输入并将其分配给NodePrinter
:#include <iostream>
#include <string>
using namespace std;
class NodePrinter;
class Node;
class BaseNode
{
public:
BaseNode() = delete;
BaseNode(Node * node);
~BaseNode();
NodePrinter * printer;
};
class Node: public BaseNode
{
public:
Node(string sequence): BaseNode(this), sequence(sequence){}
Node(int id, string sequence): BaseNode(this), sequence(sequence), id(id){}
int id;
string sequence;
};
class NodePrinter
{
private:
Node * node;
public:
NodePrinter() = delete;
NodePrinter(Node * node): node(node){}
void print_node()
{
std::cout<<node->sequence<<endl;
}
};
BaseNode::BaseNode(Node * node)
{
node->printer = new NodePrinter(node);
}
BaseNode::~BaseNode()
{
delete printer;
printer = nullptr;
}
int main()
{
Node node("abc");
node.printer->print_node();
return 0;
}
因此,每个节点被迫调用
BaseNode(this)
并分配资源。这是合理的,还是从一开始就已经扭曲了整个方法?有一个更好的方法吗?
最佳答案
在我看来,一件奇怪的事是打印机依赖于Node
的实例,难道一台打印机可能无法打印多个节点吗?而且我也不会让Node
依赖于NodePrinter
,因为那样便无法使用多台打印机来打印同一节点。
无论如何,如果您确实需要保持1对1的对应关系,最简单的方法是直接在NodePrinter
中声明成员变量的地方直接初始化Node
:
#include <iostream>
#include <memory>
#include <string>
class Node;
class NodePrinter
{
private:
Node * node;
public:
NodePrinter() = delete;
NodePrinter(Node * node): node(node){}
void print_node();
};
class Node
{
public:
Node(std::string sequence) : sequence(std::move(sequence)){}
Node(int id, std::string sequence) : id(id), sequence(std::move(sequence)) {}
int id;
std::string sequence;
std::unique_ptr<NodePrinter> printer = std::make_unique<NodePrinter>(this);
};
void NodePrinter::print_node()
{
std::cout<< node->sequence << '\n';
}
int main()
{
Node node("abc");
node.printer->print_node();
return 0;
}
在wandbox上进行现场演示。
关于c++ - 确保所有构造函数都调用相同的函数c++,设计模式,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/52439684/